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

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

对数据类型的操作

可变数据类型：列表，集合，字典

列表：

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中

不可变数据类型：元组，字符串

元组：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两边的空白字符去掉

函数

高阶函数

def func(x,y,f):

    print(f)

    print(type(f))

    return f(x)+f(y)

result=func(-3,-2,abs)

print(result)

装饰器

不修改被装饰函数的源代码

不修改被装饰函数的调用方式

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))

参数

关键字参数

位置参数

可变参数
特殊函数

面向对象

类：

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

继承：

重写父类方法

重构父类方法

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()

多态：一种接口，多种实现
方法

静态方法@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)

反射：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

模块

内置模块（标准库）

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())

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"))

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__))

第三方库（开源模块）
自定义模块
导入模块与导入包：

导入包的本质就是解释包下面的__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()

文件操作

文件读取&写入

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)  #将光标移动到最开始的地方

文件打开的模式

"r"：只读模式

"w"：创建或覆盖模式

"a"：追加模式

"r+"：读写模式

其它特性：

生成器

把列表生成式的[]改为()

[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())

巴特西