类属性：在类内直接定义的。
实例属性：通常会在构造函数中通过self去定义。
无论是类属性还是实例属性都可以随时添加。
普通的方法：默认传递的是self 代表的是对象本身 可以访问实例属性
类方法：默认传递的是cls 代表的是类本身 可以访问类属性 不能访问实例属性
静态方法：没有默认参数 但是可以通过类名访问到类属性
类方法和静态方法区别并不大。通过需要访问类属性时，使用类方法，反之，使用静态方法。
_ 不应该在类外访问，推荐在类内或者子类的类内去使用 相当于时保护的成员
__ 不应该在类外访问，也不推荐在子类访问，相当于是私有的成员。会被修改名字，修改为
_类名__成员名
python中的权限控制，在语法并没有过多的限制。只是依靠大家的使用习惯。
python支持单继承，也支持多继承，只要在类名后的括号中写上父类的名字的就可以了。
super(子类名,self).成员
如果继承的时候出现了重名，造成了二义性，python会从下往上去寻找，找到的一个，就直接使用。
python天然支持多态，因为并没有参数类型的检查。只要对象有那个函数，就可以调用。
try
raise 异常类型("抛出异常时的字符串信息")
except 异常类型 as info
得到此类型异常的时候，会执行这里
except ......
.....
finally
无论是否产生异常，都会执行finally中的语句。
filter(函数,列表) 将列表中的每一个元素传递到函数中，函数返回true，就将元素添加到新列表中
最终将新列表返回。
reduce(函数,列表) 将列表中的成员第一次取出2个，带入到函数计算。以后每次将计算的结果和列表中的下一个元素带入到函数中，直到所有元素都被使用过，最后将计算得到的值返回。
map(函数,列表) 将列表中的每一个元素传递到函数，计算，将计算结果组成一个新的列表。
这种函数一般都配合匿名函数使用
lambda 参数:返回值
python是一个完全的面向对象语言。
函数也是一个对象
def outer(num):
a = num*2
def inner(test):
return a*test
#在返回函数对象的时候，函数对象会将此时的环境信息包裹在函数对象中一并返回
#这种行为称之为闭包
return inner
m = outer(10)
print(m(5))
def w1(func):
def inner(a):
print("开始检测")
m = func(a)
print("收尾工作")
return m
return inner
@w1
def fun1(a):
print("复杂工作",a)
@w1
def fun2(b):
print("复杂工作",b)
@w1
def fun3(b):
print("复杂工作",b)
?
fun1(100)
@w1的作用就是
将w1下面的函数作用参数赋值给w1，然后将返回值返回给下面的函数。
@w1
def fun1():
...
fun1 = w1(fun1)
fun1()
import time
#获得时间戳
m = time.time()
print(m)
#将时间戳转换为元组信息
ti = time.localtime(m )
print(ti)
print(ti.tm_year)#也可以输出每一个字段
#将元组信息转换为字符串
#Y 年 m 月 d 日 H 时 M 分 S 秒
#转换的时候，不必写全，写什么就有什么
nowtime = time.strftime("%Y-%m-%d",ti)
print(nowtime)
print(time.strftime("%H-%M-%S",ti))
print(time.strftime("%Y-%m-%d-%H-%M-%S",ti))
li = nowtime.split("-")
print(li)
datatime模块
data
m = datetime.date.today() #可以是今天的日期
m = datetime.date(2019,6,5) #也可以是自定义的
print(m.timetuple())
n = m.replace(2018,1,5) #可以用replace构建一个新的
print(n)
?
time
m = datetime.time(9,23,4)
print(m)
print(m.strftime("%H--%M--%S"))
?
datetime
m = datetime.datetime.now()
print(m.timetuple())
print(m.strftime("%Y--%m--%d--%H--%M--%S"))
timedelta：专门用于时间计算的类
两个datatime对象相减 得到的就是timedelta对象
当想计算过了多少天 是什么日期，是礼拜几的时候，也需要用到这个对象
import datetime
?
m = datetime.datetime.now()
sub = datetime.timedelta(days=1)
n = m +sub #明天
print(n)
n = m-sub #昨天的这个时候
print(n)
sub = datetime.timedelta(days=365)
n = m+sub #明年
print(n)
在一个范围内生成随机数
import random
m = random.randrange(1,100)
print(m)
?
打乱序列
import random
li = [1,2,3,4,5,6,7,8,9]
random.shuffle(li) #打乱一个序列
print(li)
?
示例，生成随机验证码：
temp = ""
for i in range(0,6):
m = random.randrange(1,3)
if m==1:
n = random.randrange(1,10)#随机生成数字
temp+= str(n)
else:
n = random.randrange(65,90)#随机生成字符
temp+=chr(n)
print(temp)
示例：
#列出某一个文件夹下的所有内容
print( os.listdir("C:\\"))
#os.remove("D:\\123.txt")
m = os.path.isfile("D:\\123.txt")
print(m)
文件操作:
import os
f = open("D:\\123.txt","a+")
f.write("hello wrold")
f.close()
import threading
?
def loop():
while True:
print("--------我是子线程-------")
print(threading.current_thread().name)
?
th = threading.Thread(target=loop,name="hello 15PB")
th.start()
while True:
print("--------我是主线程-------")
多线程容易产生资源争抢问题，可能会对资源造成破坏。
解决这个问题的基本方式：
上锁
操作共享资源的时候。
解锁
import threading
?
m = 0
lock = threading.Lock()
def loop1():
global m
global lock
for i in range(0,1000000):
lock.acquire()
m +=1
lock.release()
?
def loop2():
global m
for i in range(0, 1000000):
lock.acquire()
m += 1
lock.release()
th1 = threading.Thread(target=loop1,name="hello 15PB")
th2 = threading.Thread(target=loop2,name="hello 15PB")
th1.start()
th2.start()
?
th1.join()
th2.join()
?
print(m)原文：https://www.cnblogs.com/ltyandy/p/10981655.html