Python3学习笔记

作者: 6cce91fee1d7 | 来源:发表于2017-09-04 18:07 被阅读644次

Python3学习笔记--基础知识
python3-循环
Python 爬虫笔记1 一（简单开场）
django路由url.py详解_Django学习笔记（四）-p
python3 入门笔记1
django路由views.py详解_Django学习笔记（五）
安装基本运行环境_Django学习笔记（一）-python3
视图传值和引用静态文件_Django学习笔记（二）-python
PyMoTW-3 python常用模块简介
Python3 学习笔记

注意：这个笔记只是用于我自己以后的复习使用，本人没有对其进行通用的整理，并且使用的编辑器是vim，所以没有使用Markdown的格式。

因为简书有时候会出现吞内容的情况，所以在这里添加我的GitHub。

https://github.com/shanghj01/Coding.git

#在download源代码的时候要适当选择较低的版本，因为语言的源码版本越低越能看出作者的意图

切片中[起始位置：结束位置：步长（默认是1）]

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

字符串

查找：find,index,rfind,rindex（相同都返回下标，不同，-1，异常）

replace（原，现）：替换

split（切割符）：切割

capitalize：单个首字母大写

title：全部首字母大写

endswith(str)：判断结尾

startswith（str）：判断开头

rjust(int)，ljust(int),center(int)：在int个字符中右左中对齐

strip()：去掉str两边空格，\n

partition(str)：以左起第一个str分割为元组

split(str)：以str分割

isalpha()：是否纯字母

isalnum()：是否数字字母组合

isdigit()：是否纯数字

str.join(a,b)：以str连接a，b

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

列表

增加

append()：追加(整体添加)

insert(位置，内容)：添加

extend(list)：追加list（合并list）

删除

pop()：默认最后一个

remove(str)：删除str内容

del：删除指定

修改

下标赋值

查找

in：布尔值

index：下标，异常

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

字典

增加

dict["key"] = "value"

删除

del

修改

赋值

查询

get(key)

字典操作

len(dict)：键值对个数

dict.keys()：dict的所有键

dict.values()：dict的所有值

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

元组

死的list

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

函数

def function():

不定长参数

def function(*obj):（存储为元组形式）

def function(**obj):(存储为dict形式)此时的传入格式为key=value

注意不定长参数放在参数列表的最后

拆包

要传给*obj（元组），变量前添加*

同样传给**obj（字典），添加**

匿名函数

lambda

匿名函数也是函数，同样要传参进入

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

文件

open("file","option(w,r,a)",encoding="utf-8"(可选))

flush

read（）

write()

readlines()

readline()

seek(字节,pos(0开头,1中间,2结尾))

tell() 返回地址

import os

os.rename("old","new") #重命名

os.mkdir("name") #创建dir

os.getcwd() #获取当前路径

os.chdir("newpath") #改变默认目录

os. listdir("./") #获取目录

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

面向对象

class ClassName：

#属性

注意，这里的属性可以通过下面的__init__方法里设置，而不必刻意写出

#方法

def func(self):

pass

注意这里的self相当于java中的this，在这里是建议方法中写上self

魔法方法（就是实例属性）

__init__方法

#用于初始化的方法

def __init__(self,name,age):

self.name = name

self.age= age

这里的name，age由调用类时直接写入

class(name_value,age_value)用于传入__init__方法中的name,age

__str__方法

#用于获取描述信息的方法

def __str__(self):

return "this is {},and age is {}".format(self.name,self.age).center(50,"+")

注意：这里return是必须的

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

#这里是一个例子

class Home:

def __init__(self,size,info):

self.size = size

self.usize = self.size

self.info = info

self.addObj = {}

def __str__(self):

msg = "the home initSize is {0},the useableSize is {1},and the home info is {2},the obj is {3}".format(self.size,self.usize,self.info,str(self.addObj))

return msg

def add_obj(self,obj):

self.usize -= obj.get_size()

self.addObj[obj.get_name()] = obj.get_size()

class Obj:

def __init__(self,name,size):

self.name = name

self.size = size

def __str__(self):

msg = "the obj hava {0},and it size is {1}".format(self.name,self.size)

return msg

def get_size(self):

return self.size

def get_name(self):

return self.name

home = Home(200,"这是一个房子")

bed = Obj("床",6)

print(home)

print("".center(50,"*"))

print(bed)

print("".center(50,"*"))

home.add_obj(bed)

print("".center(50,"*"))

print(home)

print("".center(50,"*"))

safa = Obj("沙发",50)

print(safa)

print("".center(50,"*"))

home.add_obj(safa)

print(home)

#到此例子结束

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

隐藏属性

私有属性属性前加__

私有方法

私有方法同样在方法名前加__ (此时表面在外部无法调用)

在类内部（且只能在内部）调用私有方法要self.__funName()

__del__方法

引用计数

在硬链接的obj完全删除时自动调用此方法

可以理解为死前的善后工作

sys模块中的getrefcount()方法

sys.getrefcount() ：用于查看一个对象被引用的次数

返回的值是引用次数+1（次数=返回值-1）

继承以及单继承

sonClass(FatherClass):

子类继承父类（基类）同样子类也可以继承父类的父类（连级继承）

重写

子类重写父类同名方法（同java）

调用被重写的方法1. fatherClass.funcName() 2. super().funcName()

私有方法、私有属性的继承

私有方法和私有属性不能被继承

但是调用的公有方法中包含有私有方法或是私有属性，这个公有方法可以被继承

多继承

object类是所有class的父类

建议类的定义中写上(object)

class C(A,B): 表示C类可以继承A类和B类

注意：在多继承中，子类继承的方法在多个父类中出现，子类会取就近优先原则，优先调用最左边的。

这里有className.__mro__属性，可以用来打印出这个类可调用的类。

多态

定义的方法或函数根据传递进的方法的不同而得到不同的结果

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

# 一个多态的小例子

class A(object):

def __str__(self):

return ("this is a ".center(20,"*"))

class B(object):

def __str__(self):

return ("this is b".center(20,"-"))

def func(temp):

print(temp)

a = A()

b = B()

func(a)

print("".center(30,"-"))

func(b)

# 例子结束

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

类属性、实例属性

定义在class内部，但是在方法外部的变量称为类的属性

实例属性：和具体的某个实例对象有关，并且实例对象不共享

类属性属于类，并且类属性在实例之间共享

和对象有关的是实例属性

类方法、实例方法、静态方法

实例方法：类中定义的方法没有特殊标注都是实例方法

类方法：需要在方法前添加 @classmethod

静态方法：在类中，方法前添加@staticmethod

静态方法可以不定义参数，也可以定义参数（self在静态方法中没啥意义）

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

# 小例子

class A(object):

#类属性

num = 0

#实例方法

def __init__(self):

self.name = "fp"

#类方法

@classmethod

def cFun(cls):

cls.num = 666

#静态方法

@staticmethod

def staFun():

print("这是一个静态方法")

a =A()

A.cFun() #类方法可以通过类的名称调用

#a.cFun() #类方法还可以通过类的对象调用

print(A.num)

A.staFun() #静态方法通过类名或对象名调用

print("".center(20,"*"))

a.staFun()

# 例子结束

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

解耦合

对于两个类有交互的时候，可以通过中间件（函数或其他方式）来解决耦合

但是在开发中，尽量使用一个类型，即用类尽量都用类，用方法尽量用方法

使用类完成解耦合-简单的工厂模式

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

#小例子

class A(object):

def __int__(self):

self.factory = Factory()

def useB(self):

return use_b

class Factory(object):

def factFun(self):

return fac

class B(object):

def theBFun(self):

return theB

#例子结束

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

__new__方法

__new__(cls)：这个方法在类被引用时会被执行（自动的，如果不被创建，类会调用默认的__new__方法）这里的cls此时指向的是类的名字[其实类是通过父类object.__new__(cls)来生成的]

__new__方法只负责创建，__init__方法只负责初始化

在此比较java和c++中的构造方法，构造方法其实包含了Python中的这两个方法

创建单例对象

不管创建多少只有一个对象

class A(object):

pass

d = A()

e = A()

print(id(a))

print(id(b))

#注意，这里的两个print的输出值并不相同

#这里不是单例模式

单例模式可以通过类变量来实现

class A(object):

__num == None

def __new__(cls):

if cls. __num = None:

cls.__num = object.__new__(cls)

return cls.__num

else :

#返回上面生成的cls.__num

return cls.__num

a = A()

b = A()

print(id(a))

print(id(b))

#此时打印的a、b的id是相同的

#也就是表明此时是单例模式

注意，在创建对象时最先调用__new__方法，这时像类中添加参数会报错，所以这时需要在__new__方法中设置虚参，只是一个样子，不需要用到

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

异常处理

try:

可能包含异常的代码片

except errName(异常的名字):#这里如果名字和异常不对应，则异常按照系统默认的方式处理

输出信息

在这里，try中的语句，如果有异常，则，异常后的语句停止，try外的语句继续运行

一个try后可以跟多个except，一个except后可以有多个异常名，不过需要添加到元组中(python3中，Python2中不需要括号)

except Exception(这是一个异常的总称，可以捕获所有异常) as tmp(只是一个变量名)

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

# 小例子

try:

1/0

open("sss0")

print(123eee)

except(NameError,FileNotFindError):

print("try中出现详细的异常")

except Exception as result:

print("这里出现一个笼统的异常,{}".format(result))

else:

print("try中没有异常时打印")

finally:

print("不管try中是否有异常，都会执行finally")

print("异常测试结束")

# 例子结束

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

自定义异常

raise

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

class UserError(Exception):

def __init__(self):

print("这里是用户自定义的异常")

try:

raise UserError

except UserError:

print("抛出自定义异常")

else:

print("没有异常")

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

异常处理中抛出异常

try:

Error

except exception as result:

if (条件):

#开启捕获异常

print(result)

else:

#重写抛出异常，此时的异常不会被捕获，交由系统处理

raise

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

if的各种真假判断

"",None,[],{},数字0，都表示假

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

模块

os.__file__

import os

xxx-cpython-35.pyc 表示c语言编写的Python编译器3.5版本的字节码

import Name

from name import defName,defName2

from name import * 注意：这里尽量不要使用这种方法导入

import Name as sName

模块中的函数或其他方法不希望在调用时重复执行，可以通过__name__变量来实现

这样，在被当做模块调用时，不会重复调用，在测试模块功能时，函数或其他方法会根据设置执行

模块中的__all__

__all__[] ：在模块中希望用*导入模块被时调用的操作，可以放入这个变量的列表中，如果不在这里，则不会被调用

包、__init__的作用

在一个文件夹下有py文件，有__init__.py文件称为包（Python3中可以不写__init__.py文件）

包中__init__.py文件的内容应含有__all__,以及from . import xxxName : 这里是对from * （all）以及 import 的导包方法的使用声明

如果__init__文件为空，导包会失败

模块的发布、安装

模块的发布

包外部同文件夹建立setup.py

######文件内容

from distutils.core import setup

setup(name = "moduleName",version = "VerDis",discription = "disInfo",author = "User",py_modules = ["modulesList"])

############################内容结束

###linux 命令中执行

python3 setup.py build

python3 setup.py sdist

##############至此，包打包结束

模块的安装################################

python3 setup.py install

#此时就把发布的包安装到Linux上了

给程序传参################################

import sys

print(sys.argv) #这里sys.argv是一个列表，0表示程序名，1:表示传入的参数

列表生成器####################################

[x for x in range(0,10,2)]

集合###########################

set 表示集合

集合中没有重复值，（集合会自动去重）

list、tuple可以有重复值，不会自动去重

字典中，当键重复时，会保留最后的那个，其他的去重（不论值是否相同）

强制类型转换得到的变量恢复到原类型用eval()

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

for循环中删除元素的坑：在循环的过程中删除元素可能出现漏删的情况。

##########例子###########

a = [1,2,3,4,5,6,7]

for i in a:

print(i, end = ",")

if i == 2 or i == 3:

a.remove(i)

print("a = {0}".format(a))

#这时输出分别为1,2,4,5,6,7,和a = [1,3,4,5,6,7]

#从这里的结果可以看出在循环中漏删了3

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

这里可以使用“缓存”的方法

用另一个变量临时存储要删除的变量，待循环结束后在删除

#############小例子#################

a = [1,2,3,4,5,6,7]

b = []

for i in a:

print(i, end = ",")

if i == 2 or i == 3:

b.append(i)

for i in b:

a.remove(i)

print("a = {0}".format(a))

#此时得到的a的结果就是完全删除的结果 a = [1,4,5,6,7]

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

对代码基本相同的类抽取基类：当不同类中的方法基本相同时，可以抽取出一个基类，用来简化代码

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

#################Python高级################

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

模块重新导入

向导入模块中添加新的路径：sys.path.append("yourPath")

重新导入模块

from imp import *

reload("old_Model") # 这里的参数是要重新导入的模块

模块的循环导入问题

a模块中导入了b模块，然而在b模块中又导入了a模块（这样就出现了一个模块导入的死递归）

解决方法：再建立一个新的模块，让这两个递归的模块成为子模块，让那个新的模块调用这两个模块

==和is的区别

==是用来判断值是否相等

is是用来判断两者之间是否存在引用关系

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

深拷贝、浅拷贝

这里的深浅指的是拷贝的程度

浅拷贝：只是对同一个变量的地址引用（地址的拷贝），这里的拷贝只是用引用指向

深拷贝：这里需要导入模块【import copy ;new = copy.deepcopy(old)】这里的拷贝是新建了内存的拷贝

copy模块中的copy和deepcopy的区别：copy只copy第一层，而deepcopy是完全copy

copy拷贝的特点：自动判断>>>当copy的对象是不可变类型时，浅拷贝，当是可变类型时，copy第一层

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

进制转换：转二进制：bin(),八进制：oct(),16进制：hex(),转10进制：int()

位运算

左移：<< 右移：>> 作用，用在快速乘法

& 按位与 | 按位或 ^ 按位异或（相同为0，相异为1）~ 取反

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

私有化

name：公有

_name：私有，from XX improt * 禁止导入，类和子类可以访问

__name：私有，避免和子类发生冲突，在外部无法访问

__name__：私有，特有的魔法方法或属性，个人最好不要创建

name_：用于区别与关键字重复

只要开头有_,基本from xx import * 就无法导入，但是只是导入模块，还是可以用的

name mangLing(名字重整)为了防止对私有属性或方法的使用（访问时可以_ClassName.__name）

property的使用

这里需要建立像Java中的setter和getter方法

###########例子################

class Test(object):

def __init__(self):

self.__num == 100

def setNum(self,newNum):

print("setter".center(20,"*"))

self.__num = newNum

def getNum(self):

print("getter".center(20,"*"))

return self.__num

new = property(setNum, getNum)

t = Test()

t.new = 666

#此时打印的结果是

#********setter**********

#********getter**********

#666

#也就是property通过setter方法和getter方法，将本不可在外部通过对象.属性的调用方式成功实现了

#################例子结束###################

这里也就是相当于用property对函数进行了一次简单的封装

#注意：这里property中的方法应先写getter方法，后写setter方法，并且方法不写括号

property也可以用装饰器的方法调用

##########例子###########

@property

def num(self):

print("getter")

return self.__num

@num.setter

def num(self,newNum):

self.__num = newNum

# 这里就不用写property(getter,setter)方法了

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

#这样的使用和上面的使用都可以

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

生成器：generator：对于要用到的变量，一边执行一边得到结果

前边提到的列表生成器只是最简单的生成器，也是最直接的

而一边操作一边得到结果的生成器是用next()进行下一步操作的，但是这里next()执行完最后一次还调用会报错。

一个函数中加了yield就表面这个函数是一个生成器了,此时按照原来的函数调用方法就不行了，返回的是一个对象。此时需要用一个变量来指向这个生成器。

此时用next()来执行生成器时，会在yield处停止，并返回yield后的参数，这个返回的参数就是生成器生成的值，在下一次调用生成器时，会在yield停止的地方接着执行。

########例子，用生成器来生成斐波那契数列###########

def fib():

a,b = 0,1

for i in range(10):

yield b

a,b = b,a+b

a = fib()

next(a)

#最后的结果应该是：55

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

这里next(generator)和a.__next__()是一样的

还有一个更高级的方法：a.send(value)

###############例子##########

def fib():

a,b = 0,1

for i in range(10):

temp = yield b

a,b = b,a+b

print(temp)

a = fib()

next(a) #这里print()的结果是None，因为生成器在yield处停止，不会对temp赋值

a.send("yeyeye") # 这里print()的结果是yeyeye，因为send()将这个值传入了temp

##############例子结束##################

注意：这里send()必须要有参数，可以是None，但是不能不写

一个生成器中可以有多个yield

协程多任务：运行一下，停一下

这里就可以用生成器的来实现多任务

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

迭代器

可迭代对象：list,tuple,dict,set,str,generator,生成器，带yield的generator function

判断是否是可迭代对象：isinstance：from collections import Iterator isinstance(ifOk,Iterator)，或者是使用for循环来判断

iter()函数用来将非迭代器转换为迭代器

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

闭包

在一个函数内部定义一个函数，并且内部的函数调用了外部函数的参数，此时，内部函数和用到的参数就叫做闭包。

######################例子################

def test(name):

def prt():

print(name += 100)

return prt

ret = test

ret(1)

#############例子结束############################

用一个变量名指向一个函数名，这样变量就相当于这个函数

对闭包的应用

###############例子###########

def test(a, b):

def test_in(x):

print(a*x+b)

return test_in

tmp = test(2, 3)

tmp(0)

#这样的好处是相当与存在一个内部存储机制，在外部函数中永久存在一个参数

#######################例子结束################

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

装饰器

在一个Python文件中，定义重名的函数不会报错，但是会使用最后的一个函数

写代码的开放封闭原则

开放：对代码进行扩展开发

封闭：对代码已实现的功能，最好不要随意修改

语法糖：写一个函数，用@符号加在其他功能前，达到一个想要的结果

#####################装饰器例子##################

def zsq(func):

def prt():

print("这是装饰器".center(10,"*"))

func()

return prt

@zsq

def f1():

print("这是一个函数".center(10,"*"))

# 这里的f1 = zsq(f1) 就相当与前边的@zsq

f1 = zsq(f1) # 这里将f1()作为参数，传入zsq()

f1() # 这里的f1已经不是原来的函数了，而是zsq()中封装的prt函数

# 得到的结果是

#*****这是装饰器*****

#*****这是一个函数*****

# 这里就达到了开放封闭原则

######################例子结束###############

多个装饰器

###############多个装饰器例子#############

def zsq1(f):

def prt1():

print("装饰器1".center(10, "*"))

return "***" + f() + "***"

return prt1

def zsq2(f):

def prt2():

print("装饰器2".center(10, "*"))

return "---"+ f() + "---"

return prt2

@zsq1

@zsq2

def test():

print("test".center(10, "*"))

return "hello world"

tmp = test()

print(tmp)

"""

这里得到的结果为：

***装饰器1***

***装饰器2***

***test***

***---hello world---***

"""

# 得到这样的结果是因为程序顺序执行，当在@zsq1时，其下部紧接着的是zsq2，这时，先将test装入了zsq2，然后返回到test'这之后才返回到zsq1，这时得到的结果就会出现上面的现象

##############################例子结束#################

装饰器执行的时间

Python解释器执行到@处时，就已经开始装饰了

装饰器对有参数，无参数函数进行装饰

当无参时，不必特别处理，当有参数时，对闭包中的函数进行设置形参，这里就可以进行有参数的函数进行装饰了

这里需要特别注意：在有参数时，可以用不定长参数的方式，*args和**kwargs,在调用装饰的函数时，需要用同样的不定长参数进行解包

装饰器对带有返回值的函数进行装饰

在闭包的函数中设置一个return 在调用被装饰的函数时，赋值，这样就可以输出

###############小例子##########

def zsq(func):

def bb():

re = func()

return re # 这里是注意点

return bb

@zsq

def test():

print("this is a test def !".center(20,"*"))

return 666

ret = test()

# 注意这里的return

通用装饰器

####################例子##################

def zsq(func):

def bb(*args, **kwargs):

print("this is a bibao")

tmp = func(*args, **kwargs)

return tmp

#注意，在Python中，如果return 返回的是None，那么不算是错误，所以，在这里一直写上return 是不算错的

return bb

@zsq

def test(a,b):

print("this is a test")

return c

ret = test(a,c)

#这是一个通用装饰器

#####################例子结束##########

带有参数的装饰器

装饰器带参数，在原有的装饰器的基础上，设置外部变量

这里的设置外部变量就是在原有的装饰器的基础上，在外部再加一个带参数的函数

####################例子####################

def func_arg(tmp):

print("the value is {}".format(tmp))

def zsq(func):

print("zsq")

def bb():

print("bb")

func()

return bb

return zsq

#注意：这里写的是外部的函数，而这个函数返回的是装饰器，所以等价于：test = zsq(test)

@func_arg(6666)

def test():

print("this is test")

##########################例子结束##############

带有参数的装饰器能起到在运行时使用不同的功能

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

作用域

命名空间：起名字的空间

globals()：查看当前空间下所有的全局变量

lobals()：查看当前空间下所有的局部变量

LEGB规则

变量的查找顺序：lobal，enclosing(外部嵌套的命名空间),global，__builtin__(内建)

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

Python动态添加属性以及方法

添加属性就是简单的"."操作，但是添加方法时，需要用到模块，types

instanceName.method = types.MethodType(nethodName, instance)

##################例子#####################

class Demo(object):

def __init__(self, name):

self.name = name

def tmp(self):

print("this is a test function for {}".format(self.name))

d = Demo("666")

import types

d.tmp = types.MethodType(tmp, d)

d.tmp()

#这样就添加了一个方法

#这个方法的输出结果为：this is a test function for 666

###################例子结束###############################

types.MethodType的作用：将对象和要添加的方法绑定

这里需要特别注意：用到types.MethodType时，只是用来添加实例对象的方法，对静态方法（staticmethod）和类方法（classmethod）只是需要用className.p = p这种方式就可以直接添加

#############例子##############

@staticmethod

def d1():

print("static method")

@classmethod

def d2():

pritn("class method")

#添加静态方法

d.d1 = d1

#添加类方法

d.d2 = d2

################例子结束###########

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

__slots__的作用

通过在类中用__slots__来限制该类实例能添加的属性

#########################例子################

class demo(object):

__slots__ = ("nim", "qqqq") #这里就限制了实例添加属性时只可以添加nim和qqqq这两个属性

#####################例子结束#########################

这里需要注意的是：__slots__只对当前类的属性有限制作用，对子类并没有作用

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

类做装饰器

用类做装饰器需要在类中定义一个__call__()方法

#############例子##################

class Demo(object):

def __init__(self, func):

print("初始化{}".format(func.__name__))

self.__func = func

def __call__(self):

print("这是类装饰器")

self.__func()

@Demo

def test():

print("test".center(20,"*"))

test()

##################例子结束############

元类

类也是对象，所以也可以在运行时动态的创建

还可以用type来创建类

type除了可以用来查看一个变量的属性，同样也可以用来创建类

type("classname", 由父类名组成的tuple(), 由属性组成的dict{})#注意：这里这种方法只是用来保证版本的兼容性，不建议用

注意：这里的type就相当于一个元类

__metaclass__属性

用于指定创建class的类

__metaclass__ = FatherName(这里也可以是一坨代码)#这里是用于定义类的生成方式这里系统默认会指定，但是自己写过后会自动调用自己的

__metaclass__用到的class自己定的话需要如下操作：#########################例子###############################

def DiyClass(class_name, class_parents, class_attribute): newAtr = {} for name, value in class_attribute.items(): if not name.startSwitch("__"): newAtr[name.upper()] = value return type(class_name, class_partents, class_attribute)在Python2中用如下操作：class NewClass(object): __metaclass__ = DiyClass pass在Python3中用如下操作：class NewClass(object, metaclass = DiyClass): pass

########################例子结束#######################################

垃圾回收

1.小整数对象池

Python中-5~256之间的整数是提前建好的，不会被垃圾回收机制回收，当用id()查看地址时，在这个范围内的整数都是相同的地址

2.大整数对象池

与小整数对象池相反

3.intern机制

字符串完全相同的引用自一个地址

单个字符共用内存

#############分隔###############

引用计数

Python中以引用计数为主

引用计数的优点：简单，实时性

引用计数的缺点：维护时占用内存，循环引用，造成内存泄露

引用计数减一不止是del，还可以通过None的赋值

隔代回收

Ruby中的垃圾回收是标记清除，对内存的申请是一次申请多个，当内存不够用时再清理，而Python中的内存申请是用一个申请一个。

隔代回收为辅

零代链表中检测到相互循环引用的减一，得到是否是垃圾（引用计数为0），需要回收，否则不会减一

GC模块

gc.get_count()：返回(x,y,z) x表示内存占用，y表示零代清理次数，z同理表示1代gc.get_threshold()：返回(x,y,z) x表示清理上限，y表示每清理零代链表10次，清理一次一代链表。z同理是1,2代这里的x,y,z默认值为(700,10,10)

查看一个对象的引用记数

sys.getrefcount()

通过gc.disable()来关Python的gc，同样也可以通过gc.enable()开启，用gc.isenabled()来判断是否是开启gc的

通过gc.collect()来显示的执行垃圾回收机制(手动执行)

这里需要注意：尽量不要手动重写对象的__del__方法，因为这样会使删除时不会自动调用gc来删除，此时需要调用父类的__del__()方法来删除

###################分隔#################################

内建属性

__init__：初始化

__new__：新建

__str__：print()如果没有，使用repr结果，美化版repr

__repr__：类实例回车或者print(类实例)，打印的结果是程序的表达方式__class__：实例.__class__

__del__：删除

__dict__：vars(实例.__dict__)

__doc__：help

__bases__：类名.__bases__

__getattribute__：访问实例属性时

__getattribute__：属性拦截器，会在所有属性使用之前调用

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

def __getattribute__(self, obj): pass

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

#######################例子#################

class Demo(object):

def __init__(self, tmp1):

self.tmp1 = tmp1

self.tmp2 = "shj"

def __getattribute__(self, obj):

print("this obj is {}".format(obj).center(20, "*"))

if obj == "":

print("the input is {}".format(self.obj))

else:

tmp = object.__getattribute__(self, obj)

print("this is not if %s" %tmp)

return tmp

def test(self):

print("this is the function named test")

s = Demo("666")

print(s.tmp1)

print(s.tmp2)

s.test()

'''这是运行结果：**this obj is tmp1**this is not if 666666**this obj is tmp2**this is not if shjshj**this obj is test**#注意这里：这里调用的test方法是显示的一个绑定this is not if>

#这里说明，类中的方法同样作为一个属性

this is the function named test

#通过这两个注意可以看到，类中的方法其实是不存在的，而是通过创建一个属性，通过对属性绑定方法来达到创建方法的操作

'''

__getattribute__的坑

################代码############

class Demo(object):

def __getattribute__(self, obj):

print("这是一个关于attribute属性的坑")

if obj.startswith("a"):

return "666"

else:

return self.test

def test(self):

print("this is the function test")

d = Demo()

print(d.a)

print(d.b)

'''

这是一个关于attribute属性的坑

666

这是一个关于attribute属性的坑

......

File "test.py", line 7, in __getattribute__

return self.test

File "test.py", line 7, in __getattribute__

return self.test

......

RecursionError: maximum recursion depth exceeded while calling a Python object

#这里报了一个错误

#这是因为：else里的self.test出现了死循环的调用getattribute

#所以，这种调用方式是不可取的，在实际操作中要注意避免

'''

#########################代码结束#####################

内建方法

range(start, stop, step)

在Python2中是直接生成，在Python3中生成器的生成方式

xrange()：功能和range()一样，但是是生成器形式的，需要用next()调用

map(function, sequence[,sequence]) 返回list 这里：function是一个函数，sequence是一个或多个序列，取决于function需要几个参数

这里参数序列中的每一个元素分别调用function，返回包含每次function的函数返回值的list

##############例子##############

a = map(lambda x:x+x, [y for y in range(1,5,1)])

for i in a :

print(i)

################例子结束###############

filter()函数：对指定序列进行过滤

filter(function, sequence)：这里的function 返回值为True或False，返回的值的类型和sequence的类型相同

reduce()函数：对序列中的数据进行累积

reduce(function, sequence, initial)：这里的initial是初始值

注意：在Python3 reduce()函数不在全局命名空间中，需要先导入functools模块，from functools import reduce

sorted()函数：排序

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

集合set

集合中的操作还可以有求交集，并集，补集。

交集：A&B 并集：A|B 补集：差集：A-B

对称差集：A^B

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

functools模块

这个模块中放置相对常用的一些方法

partial()（偏函数）：把一个函数的某些参数设置成默认值，返回一个新的函数，调用这个新的函数更简单

############例子###############

import functools

def test(*args, **kwargs):#注意这里的可变长参数，如果设置定长参数，会出现参数多给报错

print(args)

print(kwargs)

q = functools.partial(test, 1,2)

q()

q(666, 2333)

################例子结束##########################

wraps函数

用于消除装饰器在装饰函数时改变了被装饰函数的说明文档这一缺点

#############例子################

import functools

def zsq(func):

"这是一个装饰器"

@functools.wraps(func)

def a():

print("这里添加了一个装饰器")

return a

@zsq

def test():

"这里是一个测试函数"

print("this is a test")

test()

print(test.__doc__)

"""

得到的结果是：

这里添加了一个装饰器

这里是一个测试函数

"""

#这里就解决了说明文档被装饰器替代的问题

###################例子结束################

常用模块

用到的时候再查看就好

hashlib模块

用于生成hash（哈希）码等操作

####################代码#####################

import hashlib

m = hashlib.md5() #创建hash对象

print(m)

m.update(b"str") # 更新哈希对象以字符串参数,注意，这里需要先编码，不然只是字符串会报错

m.hexditest() # 返回16进制数字字符串

#############代码结束########################

Linux系统编程

pdb调试

1、运行代码时调试

python3 -m pdb fileName.py # 这里直接在Linux控制台中输入即可

l：显示当前调试的代码

n：继续向下走一步

c：继续执行代码，相当于一步到位

b num：在代码中添加断点，num代表添加断点的所在行数

b：可以查看代码中的所有断点

clear num：删除断点，num表示断点在断点存储中的序号，不是添加断点的行号,这里的clear也可以是cl

p name：打印一个变量的值,name表示变量名

a：打印所有形参的数据

s：进入一个函数

q：退出pdb调试

r：快速执行到函数的最后一行

2、交互调试

import pdb

pdb.run(funcName(attribute)) # 这里需要在pdb中先按s，然后才可以l，不然不会显示代码

3、程序里埋点

import pdb

pdb.set_trace() # 当程序遇到这句话时才进入调试

4、日志调试

print()大法好 # 在程序不停止的情况下，通过log日志热修复程序

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

pep8规则

pep8 官网规范地址

https://www.python.org/dev/peps/pep-0008/

每级缩进 4个空格

函数中的形参过长，换行时建议对齐

类间隔两个空行

方法间隔一个空行

导库：标准库，第三方，本地（个人）

类名，驼峰命名，模块，全程小写，可以用下划线

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

多任务

#这里的fork只是用于Linux（unix）仅作为了解

fork()函数，在os模块中，这个函数可以创建一个新的进程

###################例子#######################

import os

import time

ret = os.fork()

# 当程序执行到这句话，程序会新建一个进程，这时，会出现一个全新的进程来执行后边的代码

if ret == 0:

while True:

print("the one")

time.sleep(1)

else:

while True:

print("the two")

time.sleep(1)

########################例子结束#####################

# 注意，fork在windows不存在，这个只是在linux（unix）中的函数

getpid、getppid

getpid()获得当前进程的pid，getppid()获得当前进程的父进程

在新建进程之后子进程和父进程执行的基本一样（这里只是不执行父进程专有的代码，其他的代码子进程同样会执行）

全局变量在多个进程中不共享

#################例子#########################

import os, time

g_num = 666

tmp = os.fork()

if tmp == 0:

print("*"*20)

print(g_num)

g_num +=111

time.sleep(2)

print("this is son pid = {0}, ppid = {1}, g_num_id = {2}, g_num = {3}".format(os.getpid(), os.getppid(), id(g_num), g_num))

else:

print("*"*20)

print(g_num)

print("this is father pid = {0}, ppid = {1}, g_num_id = {2}, g_num = {3}".format(os.getpid(), os.getppid(), id(g_num), g_num))

##################例子结束################

多个fork()同时出现

#########代码################

import os, time

ret = os.fork()

if ret ==0:

print("1".center(10, "*"))

else:

print("2".center(10,"*"))

ret = os.fork()

if ret ==0:

print("11".center(10,"-"))

else:

print(print("22".center(10,"+")))

"""

注意：这里的结果中，包含来两个11,22

这里和前边说的在fork()处分开后，代码都会分别执行，也就是后边的fork()是在单个进程中的再一次分进程了

"""

######################代码结束################################

Process创建子进程

from multiprocessing import Process

############例子####################

from multiprocessing import Process

import time

def test():

while True:

print("*"*20)

time.sleep(1)

p = Process(target = test) # 在此开始一个新的进程

p.start() # 在此运行test中的代码

while True:

print("666")

time.sleep(1)

##################例子结束####################

主进程等待子进程结束后才停止

name.join()：这里表示堵塞等待name执行完毕之后才继续执行join()后的代码

join([timeout])：这里表示的是超时时间，等待的最长时间，timeout不是必须参数

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

Process子类

用Process子类来进行进程的控制可以达到简化的效果

###############例子####################################

#!/usr/bin/env python3

#-*- coding:utf-8 -*-

from multiprocessing import Process

import time

class Test(Process):

def run(self):

while True:

print("这里是用来测试Process的子类的一个方法")

time.sleep(1)

p = Test()

p.start()

while True:

print("this is main")

time.sleep(1)

"""

得到的运算结果是：

this is main

这里是用来测试Process的子类的一个方法

this is main

这里是用来测试Process的子类的一个方法

this is main

这里是用来测试Process的子类的一个方法

this is main

这里是用来测试Process的子类的一个方法

......

"""

#####################例子结束######################

进程池（Pool）

推荐使用这种方法创建进程

#############例子######################

#!/usr/bin/env python3

#-*- coding:utf-8 -*-

from multiprocessing import Pool

import os, time, random

def test(num):

for i in range(10):

print("the pid is {}, the num is {}".format(os.getpid(), num))

time.sleep(1)

p = Pool(3) # 这里表示设置的最大执行数

for i in range(10):

print("this is {}".format(i))

# 向Test中添加参数(i,),并运行test

p.apply_async(test, (i,))

time.sleep(1)

print("*"*10)

# 添加进程后关闭进程池

p.close()

# 进程阻塞，如果不添加这句话会出现主进程执行结束后直接关闭，子进程无法执行

p.join()

"""

this is 0