python3.x学习笔记2018-02-05更新

前言：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: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("chend+","rchen321"))
print(re.match("chend+","chen321").group())
# re.search()从字符串全局开始查找，只匹配第一个找到的
print(re.search("chend+","rchen321").group())
# 分离字符串，返回["abc","de","f"]
print(re.split("[0-9]+","abc12de34f"))
# 替换匹配到的字符，返回"abc11de14f"
print(re.sub("[0-9]","1","abc52de34f",count=3))
# 列表形式返回所有查找到的结果
print(re.findall("chend+","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:softwareAnaconda"))
print(os.path.isfile("test.py"))
print(os.path.isdir("D:softwareAnaconda"))
# 路径拼接
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 # 解释包下面的__init__.py文件
from module_name import *  #不推荐使用
from random import randint as ri # 解释包下面的randint.py文件
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
")
    f.writelines(["hello", "world", "
"])
    #逐行读取文本内容
    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())