前言：python3.x部分学习笔记，有意交流学习者可加wechat：YWNlODAyMzU5MTEzMTQ=。如果笔记内容有错，请指出来。
***

对数据类型的操作

1. 可变数据类型：列表，集合，字典
   列表：
   ```
   li=[‘a‘,‘b‘]
   增：
   li.insert(2,‘c‘) #在序号2位置上插入‘c‘
   li.append(‘d‘) #在列表末尾添加‘d‘
   li.extend(li2) #在列表li后面添加li2

删：
li.remove(‘c‘)
del li[2]
li.pop(3)

改：
li[2]=‘c‘
li[1??1]=‘ha‘

查：
li.index(‘c‘)

排序：
sort(key=lambda x:x[2],reverse=True)

集合：

去重

关系测试

s1={1,2,3,4,5},s2=set([4,5,6,7,8])
s3=s1&s2 #求交集
s4=s1|s2 #求并集

字典：

a_dict={‘name‘:‘alex‘,‘age‘:12,‘sex‘:‘male‘}
a_dict.get(‘name‘,‘wrong‘) #找键名对应的值，找不到就返回第二参数
a_dict.setdefault(‘name‘,‘lema‘) #查找该键，找不到则插入该键值对
a_dict.update(dict2) #将dict2添加到a_dict中

2. **不可变数据类型**：元组，字符串
元组：` tuple1=(1,2,3,4,5) `
字符串：

str1=‘abcdef‘,str2="a|b|c|d"
print(str1.capitalize(),str1.upper(),str1.lower()) #首字母大写,全部大写，全部小写
print(str1.find(str2,2,5)) #在str1中从序号2位置开始找str2，直到序号5的位置
print(str1.center(20,‘‘)) #在字符串两边各添加20个‘‘
print(str1.startswith(‘ab‘)+‘,‘+str1.endswith(‘ef‘)) #返回True或False
print(‘-‘.join([‘2018‘,‘1‘,‘1‘]))
print(str2.split("|",3)) #返回一个列表
print(str1.replace(‘a‘,‘A‘,1)) #把str1中的第1个a替换成A
print(str1.strip()) #把str1两边的空白字符去掉

***
###函数
1. 高阶函数

def func(x,y,f):
print(f)
print(type(f))
return f(x)+f(y)
result=func(-3,-2,abs)
print(result)

2. 装饰器
不修改被装饰函数的源代码
不修改被装饰函数的调用方式

def auth(func):
def wrapper(*args,**kwargs):
username=input("username:").strip()
password=input("password:").strip()
if "lema"==username and "qwert123"==password :
res=func(*args,**kwargs)
else :
print("wrong")
return res
return wrapper

@auth
def index(x,y,f):
print(f(x)+f(y))
print("welcome to myblog")
return "ok"
print(index(-3,-4,abs))

3. **参数**
关键字参数
位置参数
可变参数
4. **特殊函数**
***
###面向对象
1. **类**：

class People(object):
name="yin" #类变量
def init(self,name,age=6): #构造函数
self.name=name #实例变量self.name
def del(self): #析构函数，当实例对象被垃圾回收时执行该函数
print("end")
def sleep(self):
print("%s:hello,world"%self.name)
d1=People("d1",age=5)
del d1,People

2. **继承**：
重写父类方法
重构父类方法

class Man(People):
#第一种重构方式
def sleep(self):
People.sleep(self)
print("chonggou")
#第二种重构方式，建议使用第二种
def sleep(self):
super(Man,self).sleep()
print("chonggou")

多继承父类方法查询策略：广度优先

class A(object):
def func(self):
print("A")
class B(A):
# def func(self):
# print("B")
pass
class C(A):
def func(self):
print("C")
def f(self):
print("1000")
class D(B,C):
def func(self):
super(D,self).func()
super(D,self).f()
print("D")
d=D()
d.func()

3. **多态**：一种接口，多种实现
4. **方法**
静态方法` @staticmethod `：名义上归类管理，实际上访问不了类和实例中的任何属性
类方法` @classmethod `：只能访问类变量，不能访问实例变量
属性方法` @property `：把一个方法转换成静态属性

class Person(object):
def init(self,first_name,last_name):
self.first_name=first_name
self.last_name=last_name
@property
def full_name(self):
return "%s %s"%(self.first_name,self.last_name)
@full_name.setter
def first_namex(self,first_name):
self.first_name=first_name
p1=Person("Mike","Driscoll")
print(p1.full_name)
p1.first_namex="lema"
print(p1.full_name)

伪私有方法：

以双下划线开头的类方法名，在类实例化以后会自动被概念，在其名字前加 _类名.

因为名字被改了，所以自然无法用双下划开头的名字被访问，从而达到不可进入的目的

class Person(object):
def __func(self):
pass
p1=Person()
p1._Person__func()

` 类名.__doc__ `：返回该类的注释说明
` __module__ `
` __class__ `
` __call__ `
` def __str__(self): pass `：

class Dog(object):
def init(self):
print("执行init")
def str(self):
return "执行__str__"
d1=Dog()
print(d1)

5. **反射**：hasattr，getattr，setattr，delattr

def bulk():
print("往实例对象中添加一个函数")
class Dog(object):
def init(self,name):
self.name=name
def eat(self,food):
print(self.name+":"+food)
d1=Dog("lema")
choice=input(">>:").strip()

反射的是函数

if hasattr(d1,choice): #hasattr判断一个对象里是否有字符串对应的方法属性
func=getattr(d1,choice)
func("rice")
else:
setattr(d1,choice,bulk)
d1.talk() #假设输入的是talk

反射的是属性

print(d1.name)
if hasattr(d1,choice):
attr=getattr(d1,choice)
setattr(d1,choice,"ronghua")
else:
setattr(d1,choice,22)
print(d1.name) #假设输入的是name
print(d1.age) #假设输入的是age

***
###模块
1. **内置模块（标准库）**
sys

import sys
print("脚本名称：",sys.argv[0])
for i in sys.argv[1:]:
print("参数",i)

退出程序，正常退出则返回0

sys.exit(0)

标准输入

for line in sys.stdin:
print("abc",line)

time/datatime

import time,datatime
time.sleep(0.5)
today=datetime.date.today()
print(str(today.year)+‘-‘+str(today.month)+‘-‘+str(today.day))
now=datetime.datetime.now() #now.minute,now.day.now.second...

random

import random

随机生成四位验证码

checkcode=""
for i in range(4):
checkcode+=random.choice("1234567890")
print(checkcode)
print(random.randint(11,13)) #生成11或12或13
print(random.randrange(2,10,2)) #生成2，4，6，8

打乱元素

li=[1,2,3,4,5,6,7,8]
random.shuffle(li)
print(li)

hashlib

import hashlib
m1=hashlib.md5()
m1.update(b"admin")
m1.update(b"123")
print(m1.hexdigest())
m2=hashlib.md5()
m2.update("admin123".encode())
print(m2.hexdigest())

re

import re

re.match()从字符串初始位置开始查找，若初始位置开始匹配错误，返回None

print(re.match("chen\d+","rchen321"))
print(re.match("chen\d+","chen321").group())

re.search()从字符串全局开始查找，只匹配第一个找到的

print(re.search("chen\d+","rchen321").group())

分离字符串，返回["abc","de","f"]

print(re.split("[0-9]+","abc12de34f"))

替换匹配到的字符，返回"abc11de14f"

print(re.sub("[0-9]","1","abc52de34f",count=3))

列表形式返回所有查找到的结果

print(re.findall("chen\d+","chen321 chen14"))

os

import os,os.path

os.popen()返回一个file对象

cmd_res=os.popen("dir").read()
print(cmd_res)

判断文件或目录是否存在

print(os.path.exists("test.py"))
print(os.path.exists("D:\software\Anaconda"))
print(os.path.isfile("test.py"))
print(os.path.isdir("D:\software\Anaconda"))

路径拼接

print(os.path.join(‘/home/aa‘,‘/home/aa/‘,‘/home/aa/bb/c‘))

将路径与扩展名分离

print(os.path.splitext("/home/haha.py")) # 返回一个二元组

获取文件的大小

print(os.path.getsize("test.py"))

获取相关文件的系统状态信息,st_atime,st_mtime,st_ctime...

print(os.stat("test.py").st_size)

将相对路径转换成绝对路径

print(os.path.abspath(file))

2. **第三方库（开源模块）**
3. **自定义模块**
4. 导入模块与导入包的区别：
导入包的本质就是解释包下面的` __init__.py `文件
导入模块有以下几种方式：

import module1_name,module2_name
from module_name import * #不推荐使用
from random import randint as ri
from module_name import func1,func2

动态加载模块

mod1=import("baobao.test")
print(mod1)
mod1.test.func()

官方建议使用下面的用法

import importlib
mod2=importlib.import_module("baobao.test")
print(mod2)
mod2.func()

***
###文件处理
1. **文件读取&写入**

with open("test.txt","r+",encoding="utf-8") as f:
f.write("hello456\n")
f.writelines(["hello", "world", "\n"])
#逐行读取文本内容
for line in f:
print(line)
#一次性读取当前光标后的10个字符
print(f.read(10))
print(f.tell()) #获得当前文件的光标
f.seek(0) #将光标移动到最开始的地方

2. **文件打开的模式**
"r"：只读模式
"w"：创建或覆盖模式
"a"：追加模式
"r+"：读写模式
***
###其它特性：
1. **生成器**
把列表生成式的[]改为()

[i*2 for i in range(10000000)] #列表生成式，[func(i) for i in range(10)]
(i*2 for i in range(1000000)) #生成器

含yield的函数
2. **迭代**
可迭代对象：可以通过for循环来遍历的对象称为可迭代对象，比如str，dict，list，tuple，set，生成器
迭代器：可以被next()函数调用并返回下一个值的对象称为迭代器，把可迭代对象变成iterator可以使用iter()函数
3. **垃圾自动回收机制**
**del**：函数名，实例名，变量名，类名
4. **异常处理**

data={}
li=[1,2]
try:
open("test.txt",r)
data[‘name‘]
li[3]
except KeyError as e:
print("没有这个键",e)
except IndexError as e:
print("列表操作错误",e)
except Exception as e:
print("未知错误")
else:
print("一切正常")
finally:
print("不管有无错误，照常执行")

自定义异常

class AlexException(Exception):
def init(self,msg):
self.msg=msg
def str(self):
#print(self.msg)
return self.msg
try:
raise AlexException("我的异常")
except AlexException as e:
print(e)

断言

num=13
assert type(num) is str
print("right")

***
###软件目录结构规范

Foo
bin # 存放一些项目的可执行文件
一键启动.py
core # 存放项目的所有源代码
tests # 存放单元测试代码
init.py
test_main.py
init.py
main.py
docs # 存放一些文档
conf.py
abc.rst
setup.py # 安装，部署，打包的脚本
requirements.txt # 存放软件依赖的外部python包列表
README #项目说明文件
1.软件定位，软件的基本功能
2.运行代码的方法，安装环境，启动命令等
3.简要的使用说明
4.代码目录结构说明
5.常见问题说明

###多线程&多进程

import threading,time
def run(n):
print("task:",n)
time.sleep(2)
print(threading.current_thread()) # 返回当前线程对象
print(threading.active_count()) # 返回当前存活线程数量
print(threading.main_thread()) # 返回主线程对象
start_time=time.time()
t_total=[]
for i in range(50):
t2=threading.Thread(target=run,args=("t%s"%i,))
t2.setDaemon(True) # 把当前线程设置为守护线程
t2.start() # 主线程启动子线程
t_total.append(t2)

for t in t_total:

t.join() # 一个线程等到另一个线程执行结束后再执行下面的代码

end_time=time.time()
print(threading.current_thread())
print(end_time-start_time)

线程交互

import time,threading
event=threading.Event()
def lighter():
count=0
event.set() # 设置标志位
while True:
if count>5 and count<=10: # 变红灯
event.clear() # 把标志位清空
print("红灯停")
elif count>10:
event.set() # 变绿灯
count=0
else:
print("绿灯行")
time.sleep(1)
count+=1
light=threading.Thread(target=lighter,)
light.start()
def car(name):
while True:
if event.is_set():
print(" %s正在行驶"%name)
time.sleep(1)
else:
print(" %s正在等待"%name)
time.sleep(1)
event.wait()
car1=threading.Thread(target=car,args=("奔驰",))
car2=threading.Thread(target=car,args=("兰博基尼",))
car1.start()
car2.start()

queue队列

queue.Queue(maxsize=0) 顺序先入先出

queue.LifoQueue(maxsize=0) 顺序后入先出，last in first out

queue.PriorityQueue(maxsize=0) 存储数据时可设置优先级

import queue
try:
q=queue.Queue(maxsize=3)
q.put("d1")
q.put("d2")
q.put("d3")
q.put("d4",block=False)
print(q.qsize()) # 返回队列长度
print(q.get())
print(q.get_nowait())
print(q.get_nowait())
print(q.get(block=False))
print(q.get(timeout=3))
print(q.get_nowait())
except queue.Empty as e:
print("队列为空")
except queue.Full as e:
print("队列满了")

q2=queue.PriorityQueue()
q2.put((-2,"lema"))
q2.put((34,"asd"))
q2.put((11,"qwe"))
print(q2.get())
print(q2.get())
print(q2.get())
```