前言：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())

```

原文地址：https://www.cnblogs.com/lemachin/p/8416642.html