2024-06-01

source/_posts/python

基础语法

编码
默认python3源码使用UTF-8编码所有字符使用UNICODE
/# 指定源码使用的编码
/# -- coding: cp-1252 --
标识符
第一个字符字母或 _
其他部分由字母数字下划线组成
大小写敏感
保留字
1
2
>>>import keyword
>>>keyword.kwlist
注释
1
# 这是一个注释
行与缩进
python 最具特色的就是使用缩进来表示代码块
数字类型
1. int 只有一种整数类型
2. bool True False
3. float 浮点数
4. compex 复数
字符串
1. 使用’或”包裹
2. “”” 或 ‘’’ 三引号可以指定一个多行的字符串
3. \ 转义字符
4. r”\n” r可以使\不发生转义
5. 字符串可以用 + 连接
6. 字符串不能够改变
7. 没有单独的字符类型
8. 字符串切片 str[start:end] 包含start 不包含end
9. 字符串切片可以加上步长 srt[start:end:step]
空行
函数之间或方法之间用空行分割
等待用户输入
1
input("\n\n按下enter键后退出")

同一行显示多条语句

1	import sys;x = 'rtonxut'; sys.stdout.write(x+'\n');

多个语句构成代码组
缩进相同的语句构成一个代码块

if expression:
  suite
elif expression:
  suite
else:
  suite

print输出
默认输出是换行的实现不换行变量末尾加上 end=””
1
print("------",end="");

import 与 from…import
python用import或from…import 来带入相应的模块

import sys
print("-----Python import mode--------");
for i in sys.argv:
  print(i)
print("\n python 路径为",sys.path);

from sys import argv,path #导入特定的成员

print("=====Python from import=======");
print('path',path)

命令行参数
使用python -h可以查看各参数的帮助文档

基本数据类型

多个变量赋值
1
2
3
a=b=c=1

a,b,c=1,2,"hello"

Number

python3只支持int float bool complex

1
2
3

a = 20
print(type(a))
isinstance(a,int)

bool 是 int 的子类

issubclass(bool,int)
True

True==1
True

可以使del语句来删除一些对象引用

1	del val1[,val2...]

字符串

字符串使用单引号’或双引号”扩起来使用\转义特殊字符

str = "runnable"
print(str）
print(str[0,-1])
print(str[2,5])
print(str+"TEST")

bool类型

True 或 False
布尔类型可以与其他数据类型进行比较数字字符串等
比较时，True视为1 False视为0
可以和逻辑运算符一起使用 and or not

可以被转换为其他的数据类型比如整数浮点数字符串

a =True
b = False

print(2 < 3)  
print( 2 == 3)

print(a and b) 
print(a or b)
print(not a)

print(int(a))
print(float(a))
print(str(b))

列表

列表是python 使用最频繁的数据类型
列表中的元素而已不相同支持数字字符串可以包含列表

list = ['abc', 456, 43.1,'12']
tinylist = [123,'abc']

print(list)
print(list[0])
print(list[1:3])      #截取
print(tinylist*2)     #打印两次
print(list+tinylist)  #两个列表拼在一起的结果

list内置了许多方法 apped pop等

元组

元组与列表类似但是元组的元素不能修改
元组中的元素类型也可以不相同

tuple = ('abcd',432,2.23,"runnode")
tinytuple = (123,'runooda')

print(tuple)
print(tuple[0])         #输出元组的第一个元素
print(tuple[1:3])       #输出从第二个元素开始到第三个元素
print(tinytuple*2)      #打印两次
print(tuple+ tinytuple) #连接元组

集合

是一种无序可变的数据类型可以存储唯一的元素
集合中的元素不会重复
可以进行交集并集差集

sites = {'Google','Taobao','Facebook'}
sets = set('Google','Taobao');

print(sites)

if 'Google' in sites:
  print("Goolge在集合中");
esle:
  print("不在集合中");

a = set('abfjalksdjfa');
b = set('fasdgfasgagda')
print(a)

print(a - b)  #a 和 b 的差集
print(a | b)  #a 和 b 的并集
print(a & b)  #a 和 b 的交集
print(a ^ b)  #a 和 b 不同时存在的元素

字典

字典是无序的对象集合字典中的元素是通过键来存取的
在同一个字典中 key必须是唯一的

dict = {}
dict['one']="1-哈哈"
dict[2]="2-等等"

tinydict = {'name':"hahah",'code':1,'sites':''www.runoob.com}

print(dict['one'])
print(dict[2])

print(tinydict)
print(tinydict.keys())
print(tinydict.values())

bytes类型

表示的是不可变的二进制序列
bytes 中的元素是整数值 0-255 而不是unicode字符

通常用于处理二进制数据图像文件音频视频网络编程

x = b'hhello'
y = x[1:3]
z = x+b"world"

x[0] == ord('h') #比较时需要使用ord()函数将字符串转换为响应的整数值

python 数据类型转换

int(x[,base]) 将x转换为一个整数
float()
complex(real,imag)
str(x)
repr(x) 将x转换为表达式字符串
eval(x) 用来计算在字符串中的有效python表达式并返回一个对象
tuple(s) 将序列s转换为一个元组
list(s)
set(s)
dict(d) d必须是一个(key,value)元组序列
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符串转换为一个整数
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制的字符串

python3数据类学转换

隐式类型转换
python 会自动将一种数据类型转换为另外一种数据类型

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo #整数自动转换为浮点数

显式类型转换
使用int() float() str()等副定义函数进行强制转换
1
2
3
x = int(1)
y = int(2.8)
z = int("2")

python3 解释器

linux unix 系统一般默认将python3.x 装在/usr/local/python3目录中
1
2
export PATH=$PATH:/usr/local/python3/bin/python3
python --version
交互式编程
1
2
python3
>>>print("hello world")

注释

单行注释
1
# 这是一行注释

多行注释

'''
这是
多行
注释
'''

"""
这也是
多行注释
"""

python3 运算符

算术运算符

- - / % **幂 //取整除

比较运算符

== != > < >= <=

赋值运算符

= += -+ *= /= %= **= //= :=海象运算符在表达式中同时进行赋值和返回

1 2	if(n:=len(a) > 10): print(f"List is too log {(n,elements,expected <=10)}")

位运算符

& | ^ ~ << >>

逻辑运算符

and or not

成员运算符

in
not in

身份运算符

用于比较两个对象的存储单元 x is y 引用的同一个对象返回True
is
is not

数字

- 用于存储数值 
- 数据类型不允许改变 一位着如果改变数字数据类型的值，将重新分配内存空间

var1 = 1
var2 = 10
del var1
del var2,var3...

numver = oxA0F #十六进制
number = 0o37  #八进制

flo = 1.23
floa = 32.2e+18
f = 32.54e100
ff = 70.2E-12

com = 2.313+ 23j

数字函数

abs(x) 绝对值
ceil(x) 上入整数
floor(x) 下舍整数
cmp(x,y) 已废弃使用(x > y) - (x < y)
exp(x) 返回e的x次幂
fabs(x) 以浮点数返会数字的绝对值
log(x) math.log(math.e) 返回1.0 math.log(100,10) 返回2
log10(x) 返回以10为基数的对数
max(x1,x2,…)
min(x1,x2,…)
modf(x) 返回x的整数与小数部分
pow(x,y) x**y的运算结果
round(x[,n]) 返回浮点数x的四舍五入值给出n值代表舍入到小数点后的位数
sqrt(x) 返回数字x的平方根

随机函数

choice(seq) 从序列中随即挑选一个元素
randrange([start],stop,[step]) 从指定基数递增的集合中获取一个随机数基数默认值为1
random() 随即生成下一个实数
seed(x) 改变随机数生成器的种子seed
shuffle(lst) 将序列的所有元素随机排列
uniform(x,y) 随即生成曾为一个实数在[x,y]范围内

三角函数

。。。

数学常量

pi e

python3 字符串

转义字符

\续行符
\反斜杠
' 单引号
" 双引号
\a 响铃
\b 退格
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\yyy 八进制数字
\xyy 十六进制数字
\other 其他的字符以普通格式输出

字符串运算

字符串连接

重复输出字符串
[] 通过索引获取字符串中字符
[:] 截取字符串的一部分左开右闭
in 成员运算符如果字符串中包含给定的字符返回True
not in
r/R 原始字符串所有的字符串都是字面意思
% 格式字符串

字符串格式化

%c 格式化字符及其ASCII码
%s 格式化字符串
%d 整数
%u 格式化无符号整数
%o 格式化无符号八进制数
%x 无符号十六进制数
%f 浮点数
%e 用科学记数法格式化浮点数
%E 科学记数法
%g %f和%e的简写
%G %f和%E 的简写
%p 用十六进制数格式化变量的地址

格式化操作符辅助指令

- 定义宽度或者小数点精度
- 用作左对齐
- 在正数前面显示+号
在正数前面显示空格
在八进制数前显示0 十六进制前显示’0x’
0 显示的数字前面填充’0’而不是默认的空格
% ‘%%’ 输出一个单一的’%’
(var) 映射变量
m.n m是显示的最小总宽度 n是小数点后的位数

f-string

name = 'name'
f'hello {name}'   #替换变量
f'{1+2}'          #使用表达式

x=1
f'{x+1=}'         #python3.8后
  x+1=2

字符串的内建函数

capitalize() 将字符串的第一个字符转换为大写
center(width,fillchar) 返回一个指定宽度居中的字符串fillchar为填充字字符串
count(str,beg=0,end=len(string)) 返回str在string里面出现的次数
beg end 用于指定范围
bytes.decode(encoding=’utf-8’,errors=’strict’)
可以使用bytes对象的decode()方法来解码给定的bytes对象
encode(encoding=’utf=8’,errors=’strict’)
以encoding指定的编码格式编码字符串
endswith(suffix,beg=0,end=len(string)) 检查字符串是否以suffix结束
expandtabs(tabsize=8) 把字符串string中的tab符号转换为空格默认空格数为8
find(str,beg=0,end=len(string)) 检查str是否包含在字符串中返回索引值不再返回-1
index(str,beg=0,end=len(string)) 同find 不在报出异常
isalnum() 字符串至少有一个字符所有的字符都是字母或数字
isdigit() 只包含数字
islower() 所有字符都是小写
isnumeric() 只包含数字字符
isspace() 只有空格
isupper()
join(seq) 以指定的字符串作为分隔符将seq中的所有的元素合并为一个新的字符串
len(String)
ljust(width,[fillchar]) 返回一个原字符串左对齐使用fillchar 填充长度至width的新字符串
lower() 将所有字母转换为小写
maketrans() 创建字符映射的转换表
max(str) 返回字符串中最大的字母
min(str)
repalce(old,new,[max]) 将字符串中的old替换为new 如果max指定则替换不超过max次
rfind(str,beg=0,end=len(string)) 类似find() 不过是从右边查找
rindex(str,beg=0,end=len(string))
rjust(width,[fillchar])
rstrip() 删除字符末尾的空格或指定的字符
split(str=””,num=string.count(str)) 以str作为分隔符截取字符串如果num指定
仅截取num+1个子字符串
splitlines([keepends]) 按照\r \n \r\n 分隔返回一个包含各行作为元素的列表
startswith(substr,beg=0,end=len(string)
strip([chars]) 在字符串上执行 lstrip() rstrip()
swqpcase() 将字符串中大写转换为小写小写转换为大写
title() 标题化字符串所有的单词都是以大写开头其余字母均为小写
translate(table,deletechars=’’)根据table给出的表转换string字符串
要过滤的字符放到deletechars参数中
upper()
zfill(width) 返回长度为width的字符串原始字符串右对齐前面填充零
isdecimal() 是否只包含十进制字符

列表

更新列表

list = ['Google','Runoob',1997,2000]
list[2] = 2001

list.append('Badidu');
print(list)

删除列表元素

list = ['Goolge','Runnoob',1992,2000]
print(list)
del list[2]
print(list)

列表操作符

用于组合列表 * 用于重复列表
len([1,23,3]) 长度
[1,2,3]+[4,5,6] 组合
[‘Hi’]*4 重复
3 in [1,2,3]
for x in [1,23,3]: print(x,end=””)

列表的截取与拼接
L=[1,23,4,5,6,7,8]
L[2] 第三个元素
L[-1] 右侧第一个元素
L[1:] 从第二个元素开始
嵌套列表
a = [‘a’,’b’,’c’]
n = [1,2,3]
x = [a.n]
列表比较
a = [1,2,3]
b = [4,5,6]
operator.eq(a,b)
函数&方法

len(list)
max(list)
min(list)
list(seq)
list.append(obj)
list.count(obj)
list.extend(seq)
list.index(obj)
list.insert(index,obj)
list.pop([index=-1])
list.remove(obj)
list.reverse()
list.sort(key=None,reverse=False)
list.clear()

元组

修改元组

元组中的元素是不允许修改的

可以对元组进行连接组合

tup1 = (12,34,56)
tup2 = ('abc','xyz')

tup3= tup1+tup2
print(tup3)

删除元组

1 2	tup = ('Google','Runoob',1997,2000); del tup

元组运算符

len((1,2,3))
tup3= tup1+tup2
(“hhi”,”haha”)*4
3 in (1,2,3)
for x in (1,2,3): print (x,end=””)

元组的内置函数

len(tuple)
max(tuple)
min(tuple)
tuple(iterable) 将可迭代系列转换为元组

元组是不可变的

tup = (1,2,3);
tup[0]=4; #错误 不支持修改
id(tup)
tup = (4,5,6)
id(tup)

字典

创建字典

emptyDict={}
print(emptyDict)

print(len(emptyDict))
print(type(emptyDict))

访问字典里的值

1 2	tinyDict={'Name':'Runnable','Age':7,'Class':'First'} print(tinyDict['Name'])

修改字典

1 2	tinyDict ={'Name':'Tom',"Age":12} tinyDict['Age']=23;

删除字典元素

1 2	del tinyDict['Name']; del tinyDict;

字典键的特性

不允许同一个键出现两次
键必须不可变可以用数字字符串或元组但是不能够使用列表

字典的内置函数&方法

len(dict)
str(dict)
type(variable)
dict.clear()
dict.copy()
dict.fromkeys()
dict.get(key,default=None)
key in dict
dict.items()
dict.keys()
dict.setdefault(key,default=None)
dict.update(dict2)
dict.values()
pop(key,[default])
popitem()

集合

集合的创建

1
2
3

set1=set();
set2=set({1,23,4,5});
set3={2,3,5,6,7};

集合的基本操作

添加元素
s.add(x)
s.update(x1,[x2])
移除元素
s.remove(x)
s.discard(x)
s.pop()
计算集合元素个数
len(s)
清空集合
s.clear()

x in s

集合内置方法

add()
clear()
copy()
difference()
difference_update()
discard()
intersection()
intersection_update()
isdisjoint()
issubset()
issuperset()
pop()
remove()
symmetric_difference()
sysmmetric_difference_update()
union()
update()
len()

条件控制

if语句
if expression:
suite
elif expression:
suite
else:
suite
match 语句
match subject:
case < pattern_1 >:
action_1
case < pattern_2 >:
action_2
case_:
action_wildcard;

循环语句

while 语句
while(condition):
action_…
while else 语句
while(condition):
action_while
else:
action_else
for语句
for var in seq:
action1
else:
action2
range()函数
for i in range(5):
print(i)

for i in range(5,9):
print(i)

for i in range(0,10,3):
print(i)

推导式

列表推导式

names=['Bob','Tom','John','Wendy']
new_names = [name.upper() for name in names if len(name)>3]


multiples=[i for i in range(30) if i%3 == 0]
print(multiples)

字典推导式

listdemo=['Google','Baidu','Taobao']
newdict={key:len(key) for key in listdemo}

dic = {x: x**2 for x in (2,4,6)}
print(dic)

集合推导式

1 2	setnew = {i**2 for i in (1,2,3)} print(setnew)

元组推导式

1 2	a = (x for x in range(1,10)) print(a)

迭代器和生成器

迭代器是一个可以记住遍历的位置的对象
从集合的第一个元素开始访问知道所有的元素都被访问完结束
两个基本方法iter() next()

list=[1,2,3,4]
it = iter(list)
print(next(it))
print(next(it))

it = iter(list)
for x in it:
  print(x,end=" ")


import sys

list = [4,5,6,7]
it = iter(list)

while True:
  try:
    print(next(it))
  except StopIteration:
    sys.exit()

创建一个迭代器

class MyNumbers:
  def __iter_(self):
    self.a=1
    return self

  def __next__(self):
    x = self.a
    self.a+=1
    return x

myclass = MyNumvers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))

StopIteration 异常

用来标识迭代的完成防止出现无限循环的情况

class MyNumbers:
  def __iter__(self):
    self.a=1
    return self
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a+=1
      return x
    else:
      raise StopIteration

生成器

使用了yield的函数被称为生成器generator

def countdown(n):
  while n>0:
    yield n
    n-=1

generator = countdown(10)
print(next(generator))
print(next(generator))

for value in generator:
  print(value)

函数

定义函数

def hello():
  print('Hello World!\n')

hello()

def max(a,b):
  if a>b:
    return a
  else:
    return b

a= 4
b= 5
print(max(a,b))

参数传递

不可变类型
整数、字符串、元组传递的只是它的值
可变类型
列表字典将la

参数

1
2
3

def printme(str):
  print(str)
  return

必须参数
必须以正确的顺序传入函数调用时的数量必须和声明时一样
1
printme("hello")
关键字参数
使用关键字参数来确定传入的参数值
1
printme(str="hello world!")

默认参数
如果没有传递参数会使用默认参数

def printinfo(name, age=25)
  print("name",name)
  print("age",age)
  return

printinfo("tomg",24)
printinfo(name='John')

不定长参数

def functionname([formal_args,],*var_args_tuple):
  function_suite
  return [expression]




def printinfo(arg1,*vartuple):
  print("输出：")
  print(arg1)
  print(vartuple)

printinfo(70,60,50)

匿名函数

使用lamda 来承建匿名函数

lambda [arg1,...]: expression

x = lambda a:a+10
print(x(10))

return语句

用于退出函数选择性地向调用方返回一个表达式
不带参数值的return语句返回None

强制位置参数

用来指明函数形参必须使用指定位置参数

def f(a,b,/,c,d,*,e,f):
  print(a,b,c,d,e,f)

f(10,20,30,d=40,e=50,f=60)
#a b 只能使用指定位置参数 
#c d 可以是位置形参或关键字形参
#e f 要求为关键字形参

lambda 函数

lambda函数是匿名的，没有函数名称只能通过赋值给变量或作为参数传递给其他函数来使用
lambda函数通常只包含一行代码适用于编写简单的函数

f = lambda : "Hello world!"
print(f())

x = lambd a: a+10
print(x(5))


numbers = [1,2,3,4]
squared = list[map(lambda x : x**2, numbers)]
print(squared)


even_numver = list[filter(lambda x: x%2 ==0,numbers)]
print(even_numver)

product = reduce(lambda x,y: x* y,numbers)
print(product)

装饰器

decorators 是python中的一种高级功能，允许动态的修改函数或类的行为
是一种函数接受一个函数作为参数并返回一个新的函数或修改原来的函数

python 提供了一些内置的装饰器

def decorator_function(original_function):
  def wrapper(*args,**kwargs):
    before_call_code()

    result = original_function(*args,**kwargs)

    after_call_code()

    return result
  return wrapper

@decorator_function
def target_function(arg1,arg2):
  pass

带参数的装饰器

def repeat(n):
  def decorator(func):
    def wrapper(*args,**kwargs):
      for  in range(n):
        result = func(*args,**keargs)
      return result
    return wrapper
  return decorator

@repeat(3)
def greet(name):
  print(f"Hello,{name}")

greet("Alice")

类装饰器

class DecoratorClass:
  def __init__(self,func):
    self.func=func

  def __call__(self,*args,**kwargs):
      before_call_code()
      result = self.func(*args,**kwargs)
      after_call_code()
      return result

@DecoratorClass
def my_function():
  pass

数据结构

将列表当作栈来使用

#创建一个空栈
stack = [] 

#入栈
stack.append(1)
stack.append(2)
stack.append(2)
print(stack)
#输出[1,2,3]

#出栈
top_elment = stack.pop()
print(top_elment) 
#输出3
print(stack)
#输出[1,2]


#查看栈顶元素
top_elment = stack[-1]
print(top_elment)


#查看栈是否为空
is_empty = len(stack) == 0
print(is_empty)


#获取栈的大小
size = len(stack)
print(size)

将列表当作队列来使用

#collections.deque 是双端队列
from collections import deque

#创建一个空队列
queue = deque()

#向队尾添加元素
queue.append('a')
queue.append('b')

#从队首移除元素
first_element = queue.popleft()

#查看队首元素
front_element = queue[0]

#检查队列是否为空
is_empty = len(queue) == 0

#获取队列的大小
size = len(queue)

使用列表实现

#创建队列
queue = []

#向队尾添加元素
queue.append('a')
queue.append('b')

#从队首移除元素
first_element = queue.pop(0)

#查看队首元素
front_element = queue[0]

#检查队列是否为空
is_empty = len(queue) == 0

#获取队列的大小
size = len(queue)

列表推导式

1
2
3

vec  = [2,3,4,5]
new_vec = [3*x for x in vec]
print(new_vec)

嵌套列表解析

matrix = [
  [1,2,3,4]
  [5,6,7,8]
  [9,10,11,12]
]

del语句

a = [0,1,2,3,4]
del a[0]
print(a)
#[1,2,3,4]

元组和序列

tup = 12345, 54321, 'hello!'
print(tup[0])
#输出12345

print(tup)
#输出(12345,54321,'hello!')

u = t, (1,2,3,4,5)
print(u)
#输出((12345,54321,'hello!'),(1,2,3,4,5))

集合

set = {'apple','orange','pear','apple'}
print(set)
#输出 会自删除重复的元素

print('orange' in set)
#检测成员是否在集合中

a = {1,2,3,4,5,6,7}
b = {4,6,7,8,9,2}
print(a-b)
#在a不在b集合中的元素
print(a | b)
#在a或在b中的元素
print(a & b)
#既在a又在b的元素
print(a ^ b)
#不同时在a b 中的元素

字典

tel = {'Jack':4098,'Sape',4129}
print(tel['Jack'])

del tel['Sape']
print(list(tel.keys()))

print(sorted(tel.keys()))

print('Jack' in tel)


dictiionary = dict([('Jack',123).('John',456),('Tom',789)])

dict_new = {x:x**2 for x in (2,4,6)}

dict_new_2 = dict('Jack'=123,'Tom'=456)

#遍历技巧
knights = {'gallaha':'the pure','robin':'the brave'}
for k,v in knights.items():
  print(k,v)

模块

模块是一个包含所有你定义的函数和变量的文件后缀为.py

模块可以被别的程序引入以使用该模块中的函数等功能

import sys
print('命令行参数')
for i in sys.argv:
  print(i)_

print("\n\npython路径为：",sys.path,'\n')

import 语句

向使用python 源文件只需在另一个源文件里执行import 语句
1
import module1,moudle2,...

from … import 语句

让你从魔灵中导入一个指定的部分到当前命名空间中
这个声明不会把整个模块导入到当前的命名空间中
1
form modulename import name1,name2,///

深入模块

模块除了可以方法定义还可以包括可执行的代码
这些代码只有在第一次被导入时才会被执行
每个模块有各自独立的符号表在模块内为所有的函数当作全局符号来使用
1
2
3
4
from fibo import fib1,fib2
fib1()

from fibo import *

name 属性

一个模块被另一个程序第一次引入时，其主程序将运行

如果向在模块被引入时，模块中的某一程序块不被执行

if __name__ = '__main__'
  print('程序自身在运行')
else:
  print('我来自另一个模块')

每个模块都有一个__name__ 属性当其值是 main 表明该模块是自身在运行否则是被引入

dir() 函数

内置的dir()快船找到模块内定义的所有名称以一个字符串列表的形式返回

import fibo,sys
print(dir(fibo))
#输出 ['__name__','fibo','fib2']

print(dir())
#输出 当前模块定义的所有名称

标准模块

python本身自带一些标准的模块库
有些直接被构建在解析器里
这些组建会根据不同的操作系统进行不同形式的配置
winreg这个模块就智慧提供给window系统
sys 模块内置在每一个python解析器中
1
2
3
4
5
6
7
8
9
>>>import sys
>>>sys.ps1
'>>>'
>>>sys.ps2
'... '
>>>sys.ps1 = 'C>'
C> print('Hello')
Hello
C>
- sys.ps1 sys.ps2定义了主提示符和副提示符的字符串

包

包是一种管理python模块命名空间的形式采用点模样名称
A.B 表明是一个包A中的自模样B
在导入一个包时，PYTHON会根据sys.path中的目录来寻找这个包中包含的子目录
只有包含一个__init__.py的文件才会被认作是包

#每次只是导入一个包内的特定模块
import sound.effects.echo
#必须使用全名去访问
sound.effect.echo.echofilter(input,output,delay=0.7,atten=4)

#不需要每次使用前缀调用
from sound.effects import echo
echo.echofilter(input,output,delay=0.7,atten=4)


#直接导入一个函数或变量
from sound.effect.echo import echofilter
echofilter(input,output,delay=0.7,atten=4)

输入和输出

python两种输出值的方法 1 表达式语句 2 print函数
第三种使用文件对象的write()方法标准输出文件可以用sys.stdout引用
str.format()函数来格式化输出值
repr() 或 str() 可以将输出转为字符串

s = 'hello , tongzhi'
print(str(s))
#hello , tongzhi

print(repr(s))
#输出 “hello , tongzhi”

print('{}网址："{}!"'.format('菜鸟教程','www.runoob.com'))
print('{1} {0}'.format('Google','Baidu'))
#输出 Baidu Google
print('{name}网址：{site}'.format(name='菜鸟教程'，site='www.runoob.com'))

print('PI的值似{0:.3f}'.fromat(math.pi))

读取键盘输入

提供了input 内置函数从标准输入读入一行文本默认的标准输入是键盘
1
2
str = input("请输入：")
print('你输入的内容是：',str)

读和写文件

open() 将会返回一个file对象
open(filename,mode)
mode
1. r 只读
2. rb 以二进制打开只读
3. r+ 读写
4. rb+
5. w 只写不存在创建
6. wb
7. w+
8. wb+
9. a 打开一个文件用于追加文件指针放在文件的皆为文件不存在则承建
10. ab
11. a+ 读写
12. ab+

文件对象的方法

f.read(size)

#打开一个文件
f = open('/tmp/foo.txt','r')

#f.read(size) 读取一定数目的数据 size忽略或为负 该文件的所有内容都会被返回
str = f.read()
print(str)

#关闭打开的文件
f.close()

f.readline()
从文件中读取单独的一行换行符为 \n
如果返回一个空字符串说明已经读取到最后一行
f.readlines()
将返回该文件中包含的所有行
如果设置可选参数sizehint 则读取指定长度的字节并且将这些字节按行分隔
f.write(string)
将string写入到文件中返回写入的媳字符数目
如果要写入一些不是字符串的东西需要先进行转换
1
2
value = ('www.baidu.com',14)
f.write(str(value))
f.tell()
用于返回文件当前的读写位置文件指针的位置
文件指针表示从文件开头开始的字节数偏移量
f.seek()
f.seek(offset,whence)
设置文件指针的位置到相对于whence的offset偏移量的位置
f.seek(x,0) 从开始位置移动x个字符
f.seek(x,1) 从当前位置开始往后移动x的字符
f.seek(-x,2) 从文件的皆为往前移动个字符
f.close()
处理完一个文件后，调用f.close()来关闭文件并释放系统的资源

pickle模块

实现了基本的数据序列和反序列化
能够将程序中运行的对象信息保存到文件中去永久存储
通过反序列化可以从文件中创建上一次程序保存的对象
1
2
pickle.dump(obj,file,[protocol])
x=pickle.load(file)

FILE

OPEN方法
open(file,mode=’r’)
完整格式
open(file,mode=’r’,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)
参数说明
1. file 必须文件路径
2. mode 可选文件打开模式
3. buffering 设置缓冲
4. encoding 一般使用utf-8
5. errors 报错级别
6. newline 区分换行符
7. closefd 传入的file参数类型
8. opener 设置自定义开启器返回值是一个打开的文件描述符
mode
1. t 文本模式
2. x 写模式
3. b 二进制模式
4. - 可读可写
5. U 通用换行模式
6. r
7. rb
8. r+
9. w
10. wb
11. w+
12. wb+
13. a
14. a+
15. ab
16. ab+

file 对象

常用的函数

file.close()
file.flush() 刷新缓存把内部缓冲区的数据立刻写入文件
而不是等待被动输入缓冲区写入
file.fileno() 返回一个整型的fd
file.isatty() 如果文件连接到一个终端设备返回true
file.read([size]) 从文件读取指定字节数目未给定或为负则读取所有返回读取的字节数
file.readline([size])
file.seek()
file.truncate([size]) 从文件的首行首字符开始截断，截断文件为size个字符
无size表示从当前位置截断
file.write(str)
file.writelines(seq) 向文件写入一个序列字符串列表
如果需要换行则要自己加入每行的换行符

OS

os 模块提供了非常丰富的方法用来处理文件和目录

os.access(path,mode）检验权限模式
os.chdir(paht) 改变工作目录
os.chflags(path,flags) 设置炉具的标记为数字标记
os.chmod(path,mode) 更改权限
os.chown(path,uid,gid)
os.chroot(path) 改变当前进程的根目录
os.close(fd) 关闭文件描述符
os.closerange(fd_low,fd_high) 关闭所有的文件描述符
os.dup(fd) 复制文件描述符
os.dup2(fd,fd2) 将一个文件描述符fd 复制到另一个 fd2
os.fchdir(fd）通过文件描述符改变当前的工作目录
os.fchmod(fd,mode)
os.fchown(fd,uid,gid)
os.fdatasync(fd) 强制将文件写入磁盘但是不强制更新文件的装入了信息
os.fdopen(fd[,mode[,bufsize]]) 通过文件描述符创建一个文件对象
os.fpathconf(fd,name) 返回一个打开文件的系统配置信息 name为检索的系配置的值
os.fstat(fd) 返回文件描述符的状态
os.fstatvfs(fd) 返回包含文件描述符fd的文件系统的信息
os.fsync(fd) 强制将文件写入到硬盘
os.ftruncate(fd,length) 裁剪fd对应的文件
os.getcwd() 返回当前的工作目录
os.getcwdb() 返回当前工作目录的Unicode对象
os.isatty(fd) 终端设备返回true
os.lchmod(path,mode) 修改连接文件权限
…

错误和异常

语法错误
语法解析器指出的错误
异常
运行期间检测到的错误

异常的捕捉

while True:
  try:
    x = int(input("请输入一个数字"))
    break;
  except ValueError:
    print("你输入的不是数字，请再次尝试输入！");


import sys
try:
  f = open('myfile.txt')
  s = f.readline()
  i = int(s.strip())
except OSError as err:
  print('Os Error: {0}'.format(err))
except ValueError:
  print("Could not convert data to an integer")
except:
  print("Unexpected error:",sys.exc_info()[0])
  raise

for arg in sys.argv[1:]:
  try:
    f = open(arg,'r')
  except IOError:
    print("cannot open",arg)
  else:
    print(arg,'has',len(f.readlines()),'lines')
    f.close()


try:
  runoob()
except AssertionError as err:
  print(err)
else:
  try:
    with open('file.log') as file:
      read_data = file.read()
  except FileNotFoundError as fnf_err:
    print(fnf_err)
  finally:
    print('这句话，无论是否发生都会执行')

抛出异常

raise [Exception [,args[,traceback]]]

1
2
3

x =10 
if x> 5:
  raise Exception('x 不能大于5. x 的值为 {}'.format(x))

用户自定义异常

可以通过创建一个新的异常类来拥有自己的异常

class MyError(Exception):
  def __init__(self,value):
    self.value=value
  def __str__(self):
    return repr(self.value)
try:
  raise MyError(3*2)
except MyError as e:
  print('My Exception occured,value = ',e.value)

定义清理行为

定义了无论在任何情况下都会执行的清理行为
try:
raise KeyBoardInterrupt
finally:
print(‘Goodbye,world!’)

for line in open("Myfile.txt"):
  print(line,end='')
#当代码执行完后 文件会保持打开的状态

with open('myfile.txt') as f:
  for line in f:
    print(line,end='')
#with语句保证了诸如文件这类的对象在使用完毕之后一定会正确的执行他的清理方法

面向对象

init() 构造方法
self 代表实例而不是类

def 定义一个方法

class MyClass:
  __weight= 0 #私有属性
  def __init__(self,value):
    self.value = value;
  def dispaly_value(self):
    print(self.value)

obj = MyClass(42)

obj.dispaly_value()

继承

class DerivedClassName(Base1,Base2,Base3):
  ...

class people:
  name = ''
  age = 0 
  __weight = 0

  def __init__(self,n,a,w):
    self.name=n
    self.age=a
    self.__weight = w

  def speak(self):
    print('{}说：我{}岁了'.format(self.name,self.age))

class student(people):
  grade = ''
  def __init__(self，n,a,w,g):
    people.__init__(self,n,a,w)
    self.grade= g

  def speak(self):
    print(f"{}说：我{}岁了，我在上{}年级",self.name,self.age,self.grade)

类属性和方法

__private_attrs 双下划线表明该属性为似有属性

__private_method 私有方法

class JustCounter:
  __secretCount = 0
  publicCount = 0

  def count(self):
    self.__secretCount+=1
    self.publicCount+=1
    print(self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)#报错



class Site:
  def __init__(self,name,url):
    self.name = name
    self.__url = url

  def who(self):
    print('name:',self.name)
    print('url:',self.__url)

  def __foo(self):
    print("这是私有方法")

  def foo(self):
    print("这是公有方法")
    self.__foo()

x=Site('Baidu','www.baidu.com')
x.who()
x.foo()
x.__foo() #报错

类的专有方法

init 构造函数
del 析构函数
repr 打印转换
setitem 按照索引赋值
getitem 按照索引获取值
len 获得长度
cmp 比较运算
call 函数调用
add 加运算
sub 减运算
mul 乘运算
truediv 除运算
mod 求余运算
pow 乘方

运算符重载

class Vector:
  def __init__(self,a,b):
    self.a= a
    self.b = b

  def __str__(self):
    return "Vector ({},{})".fromat(self.a,self.b)

  def __add__(self,other):
    return Vector(self.a+other.a,self.b+other.b)

v1= Vector(2,10)
v2 = Vector(5,-2)
print(v1+v2)
#输出 Vector(7,8)

命名空间和作用域

一般有三种命名空间

内置名称built-in names 语言内置的名称函数名abs char BaseEXception等等
全局名称global names 模块中定义的名称记录模块的变量
局部名称local names 函数中定义的名称

var1 = 5   #全局名称
def some_func():
  var2 = 6  #局部名称
  def some_inner_func():
    var3 = 7  #内嵌的局部名称

作用域

是一个python程序可以直接访问命名空间的正文区域

四种作用域

L(Local) 最内层比如一个函数方法内部
E(Enclosing) 包含了非局部也非全局的变量
G(Global) 当前脚本的最外层
B(Built-in）包含了内建的变量/关键字等等

规则顺序
L->E->G->B

PYTHON3标准库

OS模块 SYS模块 time模块 datetime模块 random模块 math模块 re模块 json模块 urllib模样

OS模块

提供了不少与操作系统相关的函数
import os

current_dir = os.getcwd()
print('当前的工作目录：',current_dir)

files = os.listdir(current_dir)
print('目录下的文件：',files)

GLOB

提供了一个函数用影视从目录通配符搜索中生成文件列表

1 2	import glob glob.glob('*.py')

命令行参数

命令行参数以链表的形式存储于 sys模块的 argv 变量

1 2	import sys print(sys.argv)

错误输出重定向和程序终止

sys 有stdin stdout stderr属性

1 2	sys.stderr.write('Warning, log file not found starting a new one\n'); sys.exit()

字符串正则匹配

1 2	import re re.findall(r'\bf[a-z]*','wich foot or hand fell fastest')

数学

提供了浮点运算对底层C库的访问

1
2
3

import math
math.cos(math.pi/4)
math.log(1024,2)

随机数

import random
random.choice(['apple','pear','banana'])
random.sample(range(100),10)
random.random()
random.randrange(6)

访问互联网

form urllib.request import urlopen
for line in urlopne('http://tycho.usno.navy.mil/cgi-bin.timer.pl'):
  line = line.decode('utf-8')
  if 'EST' in line or 'EDT' in line:
    print(line)

import smtplib
server = smtplib.SMTP('localhost')
server.sendmail('soothsyaer@example.org','jcasear@exampler.org',
"""
  some message
""
)

server.quit()

时间和日期

import datetime

current_datetime=datetime.datetime.now()
print(current_datetime)

current_date = datatime.date.today()
print(current_date)

formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)

数据压缩

zlib gzip bz2 zipfile tarfile

import zlib
s  = b'witch which has which witches wrist'
print(len(s))

t = zlib.compress(s)
print(len(t))

print(zlib.decompress(t))

print(zlib.crc32(s)

性能度量

1
2
3

from timeit import Timer
t=Timer('zlib.compress(s)').timeit()
print(t)

正则表达式

python 中使用re.模块来处理正则表达式

re.match函数

从字符串的其实位置匹配一个模式如果不是起始位置匹配成功的话返回NONE
re.match(pattern,string,flags)
return 一个匹配的对象否则返回NONE
可以使用group(num) groups()匹配对象函数来获取匹配表达式
1
2
3
4
5
6
import re

print(re.match('www','www.baidu.com').span())
#返回(0,3)
print(re.match('com','www.baidu.com'))
#返回None

import re
line = 'Cats are smater than dogs'
mObj = re.match(r'(.*) are (.*?) .*',line,re.M|re.I)
print(mObj.groups())
#返回('Cats','smater')
print(mObj.group(0))
#返回'Cats are smater than dogs'
print(mObj.group(1))
#返回Cats 
print(mObj.group(2))
#返回smater

re.search函数

扫描整个字符串并返回第一个成功的匹配
re.search(pattern,string,flags=0)

1
2
3

import re 
print(re.search('www','www.baidu.com').span())
print(re.search('www','com.baidu.www').span())

import re

line = 'Cats are smater than dogs'

sObj = re.search(r'(.*) are (.*?) .*',line,re.M|re.I)
print(sObj.groups())
print(sObj.group())
print(sObj.group(1))
print(sObj.group(2))

检索和替换

re.sub用于替换字符串中的匹配项
re.sub(pattern,repl,string,count=0,flags=0)
前3个参数为必选，后2个为可选参数

repl 也可以是一个函数

import re
phone = '2004-959-559 #这是一个电话号码'
num = re.sub(r'#.*$',"",phone)
print(num)
#返回2004-959-559 
num = re.sub(r'\D','',phone)
print(num)
#返回2005959559

import re

def double(matched):
  value = int(matched.grou('value'))
  return str(value*2)

s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)',double,s))

compile函数

用于编译正则表达式
re.compile(pattern[,flags])
flags:
1. re.L 表示特殊字符集 \w \W \b \B \s \S 以来于当前环境
2. re.MULTILINE 或 re.M 多行模式改变^ $的行为
3. re.DOTALL或re.S 使.匹配包括换行符在内的任意字符
4. re.ASCII 使\w \W \b \B \d \D \s \S 仅匹配ASCII
5. re.VERBOSE 或 re.X 忽略空格和注释
6. re.IGNORECASE 或 re.I 使匹配对大小写不敏感
标志位可以单独使用也可以通过按位或 | 组合使用

import re
pattern = re.compile(r'\d+')
m = pattern.match('one12twothree34four')
print(m)
#None
m = pattern.match('one12twothree34four',2,10)
print(m)
#None
m = pattern.match('one12twothree34four',3,10)
print(m)
m.group(0)
m.start(0)
m.end()
m.span()

import re
pattern = re.compile(r'([a-z]+) ([a-z]+)',re.I)
m = pattern.match('Hello World Wide Web')
print(m)
m.group()
m.span()
m.group(1)
m.span(1)
m.group(2)
m.span(2)
m.groups()
m.group(3) #error

findall 函数

在字符串中找到正则表达式所匹配的所有字符字串并返回一个列表
如果有多个匹配模式则返回元组列表
如果每有匹配返回空列表
re.findall(pattern,string,flags =0)
或
pattern.findall(string[,pos[,endpos]])

-pos 可选参数指定字符串的起始位置默认0
-endpos 可选参数指定字符串的结束位置默认字符串的长度

import re
result1 = re.findall(r'\d+','runoob 123 google 456')

pattern = re.compile(r'\d+')
result2 = pattern.findall('runoob 123 google 456')
result3 = pattern.findall('run88oob123google456',0,10)

print(result1)
#['123','456']
print(result2)
#['123','456']
print(result3)
#['88','12']

import re

result = re.findall(r'(\w+)=(\d+)','set width=20 and height=10')
print(result)
#[('width','20'),('height','10')]

re.finditer

在字符串中找到正则表达式所匹配的所有子串并把他们作为一个迭代器返回
re.finditer(pattern,string,flags=0)

import re
it = re.finditer(r'\d+','12a32bc43jf3')
for match in it:
  print(match.group())

re.split函数

re.split(pattern, string[,maxsplit=0,flags=0])

-maxsplit 分割次数 maxsplit=1 分割一次默认=0 不限制次数

import re
re.split('\W+','runoob, runoob, runoob.')
#['runoob','runoob','runoob']
re.split('(\W+)',' runoob, runoob, runoob')
#['runoob',',','runoob',',','runoob']
re.split('\W+',' runoob, runoob, runoob.',1)
#['','runoob, runoob, runoob.']

re.split('a*','hello world')

正则表达式对象

re.RegexObject

re.compile() 返回RegexObject对象

re.MatchObject

group() 返回被RE匹配的字符串
start() 返回开始的位置
end() 返回结束的位置
span() 返回一个元组包含匹配的位置

正则表达式修饰符可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式
可以单独使用也可以组合使用 |

re.IGNORECASE 或 re.I 对大小写不敏感
re.MULTILINE 或 re.M 多行匹配
re.DOTALL 或 re.S 使得.匹配包括换行符在内的任意字符
re.ASCII 使/w/W /b/B /d/D /s/S 仅匹配ASCII字符
re.VERBOSE 或 re.X 忽略空格和注释

正则表达式模式

字母和数字表示他们自身
多数字母和数字前加一个\会有不同的含义
\需要使用\转义
标点符号只有被转义才匹配自身

^ 匹配字符串的开头
$ 匹配字符串的结尾
. 匹配任意字符除了换行符 re.DOTALL 可以匹配换行符
[…] 用来匹配所包含的任意一个字符
[^…] 匹配不包含的任意一个字符
re* 匹配0个或多个的表达式
re+ 匹配1个或多个的表达式
re? 匹配0个或1个的表达式
re{n} 匹配n个前面的表达式
re{n,} 精确匹配n个前面的表达式
re{n,m} 匹配n到m此由前面的正则表达式定义的片段贪婪方式
a|b 匹配a或b
(re) 匹配括号内的表达式也表示一个组
(?imx) 正则表达式包含3种可选标志：i m x 只影响括号中的区域
(?-imx) 关闭 i m x 可选标志
(?:re) 类似(…) 不表示一个组
(?imx:re) 在括号中使用i m x可选标志
(?-imx:re)
(?#。。。) 注释
(?=re) 前向肯定界定符
(?!re) 前向否定界定符
(?>re) 匹配的独立模式省去回溯
\w 匹配数字字母下划线
\W 匹配非数字字母下划线
\s 匹配任意空白字符等价于[\t\b\r\f]
\S 匹配任意非空字符
\d 匹配任意数字
\D 匹配任意非数字
\A 匹配字符串的开始
\Z 匹配字符串的结束换行前的结束字符串
\z 匹配字符串结束
\G 匹配最后匹配完成的位置
\b 匹配一个单词边界
\B 匹配非单词边界
\n \t 等等匹配一个换行符一个制表符等等
\1…\9 匹配第n各分组的内容
\10 匹配第n各分组的内容

多线程

python3中有2个模块

_thread
threading（推荐使用）

_thread.start_new_thread(function,args[,kwargs])
function 线程函数
args 传递给线程函数的参数必须是tuple类型
kwargs 可选参数

import _thread
import time
def print_time(threadName,delay):
  count = 0
  while count<5:
    time.sleep(delay)
    count+=1
    print(threadName,time.ctime(time.time()))
try:
  _thread.start_new_thread(print_time,('Thread-1',2))
  _thread.start_new_thread(print_time,('Thread-2',4))
except:
  print('线程无法启动')

while 1:
  pass

threading模块

_thread提供了低级别的原始的线程及一个简单的锁
threading 模块除了_thread模样中的所有方法外，还提供了其他方法
threading.current_thread() 返回当前线程变量
threading.enumerate() 返回正在运行的线程数量
threading.active_count() 返回正在运行的线程数量
threading.Thread(target,args=(),kwargs={},daemon=None):
创建Thread实例，
target 线程将要执行的目标函数
args 目标函数的参数元组方式传递
kwargs 目标函数的关键字参数以字典形式传递
daemon 指定了线程是否为守护进程

threading.Thread 类提供了以下的方法和属性：
1. init(self,group=None,target=None,name=None,args=(),kwargs={},*,daemon=None)
初始化对象
group 线程组暂未使用
target 线程将要执行的目标函数
name 线程的名称
args 目标函数的参数
kwargs 目标函数的关键字参数
daemon 指定线程是否为守护线程
2. start(self)
启动线程
3. run(self)
线程在此方法中要执行的代码
4. join(self,timeout=None)
等待线程终止默认情况下join()会一直阻塞直到被调用线程终止
指定timeout 最多等待timeout秒
5. isalive(self)
返回线程是否在运行 True False
6. getName(self)
返回线程的名称
7. ident属性
线程的唯一标识符
8. daemon属性
线程的守护标志用于指定是否是守护进程
9. isDaemon()

import threading
import time

def print_numbers():
  for i in range(5):
    time.sleep(1)
    print(i)
thread = threading.Thread(target=print_numbers)
thread.start()
thread.join()

import threading
import time

exitFlag=0

class MyThread (threading.Thread):
  def __init__(self,threadID,name,delay):
    threading.Thread.__init__(self)
    self.threadID = threadID
    self.name = name
    self.delay = delay
  def run(self):
    print("start of thread:"+self.name)
    print_time(self.name,self,delay,5)
    print("exiting thread:"+self.name)

  def print_time(threadName,delay,counter):
    while counter:
      if exitFlag:
        threadName.exit()
      time.sleep(delay)
      print(threadName,time.ctime(time.time()))
      counter-=1

thread1 = MyThread(1,"Thread-1",1)
thread2 = MyThread(2,"Thread-2",2)

thread1.start()
thread2.start()

thread1.join()
thread2.join()
print("exit the main thread!")

线程同步

import threading
import time

class myThread(threading.Thread):
  def __init__(self,threadID,name,delay):
    threading.Thread.__init__()
    self.threadID=threadID
    self.name = name
    self.delay = delay
  
  def run(self):
    print("start new thread:"+self.name)
    threadLock.acquire()
    print_time(self.name,self.delay,3)
    threadLock.release()

def print_time(threaName,delay,counter):
  while counter:
    time.sleep(delay)
    print(threadName,time.ctime(time.time()))
    counter-=1

threadLock = threadingLock()
threads=[]

thread1 = myThread(1,'Thread-1',1)
thread2 = myThread(2,'Thread-2',2)

thread1.start()
thread2.start()

threads.append(thread1)
threads.append(thread2)

for t in threads:
  t.join()
print('exit the main thread')

线程优先级队列 Queue

Queue模块提供了同步的线程安全的队列类 FIFO Queue LIFO LifoQueue 优先级队列
PriorityQueue

Queue方法
Queue.qsize() 返回队列的大小
Queue.empty() 空返回True 否则返回False
Queue.full() 满了返回True
Queue.full 与 maxsize 大小对应
Queue.get([block[,timeout]]) 获取队列 timeout 等待时间
Queue.get_nowait() 相当于Queue.get(False)
Queue.put(item)
Queue.put_nowait()
Queue.task_done() 向任务已经完成的队列发送一个信号
Queue.join() 等到队列为空再执行别的操作

import queue
import threading
import time

exitFlag = 0

class MyThread(threading.Thread):
  def __init__(self,threadID,name,q):
    threading.Thread.__init__(self)
    self.threadID=threadID
    self.name = name
    self.q = q

  def run(self):
    print('start thread:'+self.name)
    process_data(self.name,self.q)
    print('exit thread:'+self.name)

def process_data(threadName,q):
  while not exitFlag:
    queueLock.acquire()
    if not workQueue.empty():
      data = q.get()
      queueLock.release()
      print(threadName+data)
    else:
      queueLock.release()
    time.sleep(1)

threadList = ['Thread-1','Thread-2','Thread-3']
nameList = ['One','Two','Three']
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

for tName in threadList:
  thread = MyThread(threadID,tName,workQueue)
  thread.start()
  threads.append(thread)
  threadID+=1

queueLock.acquire()
for word in nameList:
  workQueue.put(word)
queueLock.release()

while not workQUeue.empty():
  pass

exitFlag =1

for t in threads:
  t.join()
print('exit thre main thread')

日期和时间

time 模块和 calender 模块

time.time() 时间戳
时间元组
struct_time =
(tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
time.localtime(time.time())
time.strftime(format[,t])
年 %y 00-99 %Y 000-9999
月 %m 01-12
日 %d 0-31
小时 %H 0-23 %I 01-12
分 %M 00-59
秒 %S 00-59

星期本地简化%a 本地完整%A
月份本地简化%b 本地完整%B
本地相应的日期表示和时间表示
%c

年内的一天001-366
%j

本地A.M. 或 P.M.的等价符
%p

一年中的星期数00-53
%U 星期天为开始
%W 星期一为开始

星期0-6
%w

本地相应的日期表示
%x

本地相应的时间表示
%X

当前时区的名称
%Z

%% %符号本身
获取格式化时间
time.asctime(time.localtime(time.time()))
获取某月日历
calendar.month(2016,1)

time 模块

time.altzone 返回utc 偏移秒数
time.asctime([tupletime]) 返回一个24个字符的字符串
time.perf_counter() 返回系统运行时间
time.process_time() 返回进程运行时间
time.ctime([secs]) 相当于 time.asctime(time.localtime())
time.gmtime([secs]) 返回时间元组
time.localtime([secs]) 返回当地时间下的时间元组
time.mktime(tupletime)
time.sleep(secs) 睡眠secs秒
time.strftime(fmt[,tupletime])
time.strptime(str,fmt=’%a %b %d %H:%M:%S%Y’)
根据fmt的格式把一个时间字符串解析为时间元组
time.time() 返回时间戳
time.tzset() 根据环境变量TZ重新初始化时间相关设置
time.perf_counter() 返回计时器的精准时间
time.process_time() 返回当前进程执行cpu的时间总和
time.timezone 当地时区
time.tzname 包含一对跟坏情况不同而不同的字符串

Calendar 模块

calendar.calendar(year,w=2,l=1,c=6)
3个月一行间隔距离 c 每日宽度 w 字符每行长度21w+18+2c
calendar.firstweekday() 返回每周起始日期的设置默认0 周一
calendar.isleap(year) 闰年返回 True
calendar.leapdays(y1,y2) 返回在y1 y2 间的闰年
calendar.month(year,month) 返回一个整数的单层嵌套列表
calendar.montrange(year,month) 返回两个整数
calendar.setfirstweekday(weeday) 设置每周的起始日期码
calendar.timegm(tupletime) 返回时间戳
calendar.weekday(year,month,day) 返回给定日期的日期码

XML 解析

ElementTree SAX DOM

ElementTree

解析XML

fromstring() 方法将包含xml数据的字符串转换为Element对象

parse() 方法解析整个XML文档

import xml.etree.ElementTree as ET
xml_string = '<root><element>Some Data</element></root>'
root = ET.fromstring(xml_string)

tree = ET.parse('example.xml')
root = tree.getroot()

遍历XML树

find()方法查找指定标签的第一个子元素

findall() 方法查找具有指定标签的偶有子元素

1 2	title_element = root.find('title') book_elements = root.findall('book')

访问元素的属性和文本内容

#attrib 访问元素的属性
price = book_element.attrib['price']
#text 访问元素的文本内容
title_text = title_element.text

创建XML

1 2	new_element = ET.Element('new_element') new_sub_element = ET.Element(root,'new_element')

修改XML

1	root.remove(title_element)

import xml.etree.ElementTree as ET
xml_string="""
<bookstore>
  <book>
    <title>Introduction to Python</title>
    <author>Jhon Doe</author>
    <price>29.99</price>
  </book>
  <book>
    <title>Data Science with Python</title>
    <author>Jane Smith</author>
    <price>39.95</price>
  </book>
</bookstore>
"""

root = ET.fromstring(xml_string)

for book in root.findall('book'):
  title = book.find('title').text
  author = book.find('author').text
  price =  book.find('price').text
  print(f'Title:{title}, Author:{author},Price:{price}')

import xml.etree.ElementTree as  ET

root = ET.Element('bookstore')

book1 = ET.SubElement(root,'book')
title1 = ET.SubElement(book1,'title')
title1.text = 'Introduction to Python'
author1 = ET.SubElement(book1,'author')
author1.text = 'John Doe'
price1 = ET.SubElement(book1,'price')
price1.text = '29.99'

book2 = ET.SubElement(root,'book')
title2 = ET.SubElement(book2,'title')
title2.text = 'Data Science with Python'
author2 = ET.SubElement(book2,'author')
author2.text = 'Jane Smith'
price2 = ET.SubElement(book2,'price')
price2.text = '39.95'

tree = ET.ElementTree(root)
tree.write('books.xml')

parsed_tree = ET.parse('books.xml')
parsed_root = parsed_tree.getroot()

for book in parsed_root.findall('book'):
  title = book.find('title').text
  author = book.find('author').text
  price = book.find('price').text
  print(title, author, price)

SAX

ContentHandler 类方法介绍
1. characters(content) 方法
2. startDocument() 方法
3. endDocument() 方法
4. startElement(name,attrs)
5. endElement(name)
make_parser方法
创建一个新的解析器对象并返回
xml.sax.make_parser([parser_list])
- parser_list 可选参数解析器列表
parser 方法
xml.sax.parseString(xmlstring,contenthandler[,errorhandler])
- xmlstring xml字符串
- contenthandler ContentHandler对象
- errorhandler SAX ErrorHandler对象

import xml.sax

class MovieHander(xml.sax.ContentHandler):
  def __init__(self):
    self.CurrentData = ''
    self.type = ''
    self.format = ''
    self.year = ''
    self.rating = ''
    self.stars = ''
    self.description = ''

  def startElement(self,tag,attributes):
    self.currentData = tag
    if tag == 'movie':
      print('*****Movie*****')
      title = attributes['title']
      print('Title:',title)

  def endElement(self,tag):
    if self.CurrentData == "type":
      print("Type:",self.type)
    elif self.CurrentData == 'format':
      print('Format:',self.format)
    elif self.CurrentData == 'year':
      print('Year:',self.year)
    elif self.CurrentData == 'rating':
      print('Rating:',self.rating)
    elif self.CurrentData == 'stars':
      print('Stars:',self.stars)
    elif self.CurrentData == 'description':
      print('Description:',self.description)
    self.CurrentData = ''

  def characters(self,content):
    if self.CurrentData == 'type':
      self.type = content
    elif self.CurrentData == 'fromat':
      self.format = content
    elif self.CurrentData == 'year':
      self.year = content
    elif self.CurrentData == 'rating':
      self.rating = content
    elif self.CurrentData == 'stars':
      self.stars = content
    elif self.CurrentData == 'description':
      self.description = content

if(__name__ == "__main__"):
  parser = xml.sax.make_parser()
  #个某处命名空间
  parser.setFeature(xml.sax.handler.feature_namespaces = 0)

  Handler = MovieHander()
  parser.setContentHandler(Handler)
  parser.parse('movies.xml')

xml.dom 解析xml

文件对象模型Document Object Model DOM

from xml.dom.minidom import parse
import xml.dom.minidom

DOMTree = xml.dom.minidom.parse('movies.xml')
collection = DOMTree.documentElement
if collection.hasAttribute('shelf'):
  print('Root element : %s'% collection.getAttribute('shelf'))

movies = collection.getElementsByTagName('movie')

for movie in movies:
  print('*****Movie*****')
  if movie.hasAttribute('title'):
    print('Title: %s'% movie.getAttribute('title'))
  
  type = movie.getElementsByTagName('type')[0]
  print('Type: %s'% type.childNodes[0].data)
  format = movie.getElementsByTagName('format')[0]
  print('Format: %s'% format.childNodes[0].data)
  rating = movie.getElementsBytagName('rating')[0]
  print('Rating:%s'% rating.childNodes[0].data)
  description = movie.getElementsByTagName('description')[0]
  print('Description : %s'% description.childNodes[0].data)

网络编程

低级别的网络服务支持基本的Socket
高级别的网络服务支持服务器中心类 SocketServer

socket() 函数
socket.socket([family[,type[,[[[proto]]])

family 套接字家族可以是AF_UNIX AF_INET
type 面向连接SOCK_STREAM 非连接SOCK_DGRAM
proto 一般不填默认0

Socket 对象的方法
服务器端套接字
s.bind() 绑定到(host,port)
s.listen() 开始TCP监听 backlog指定在拒绝连接前可以挂起的最大数连接数至少为1
大部分设置为5
s.accept() 阻塞式等待连接的到来

客户端套接字
s.connnect() 主动初始化TCP服务器连接返回SOCKET.ERROR错误
s.connect_ex() 出错返回错误码而不是抛出异常

公共用途的套接字函数
s.recv() 数据以字符出的形式返回 bufsize指定要接受的最
s.send()
s.sendall()

s.recvfrom() UDP
s.sendto() UDP

s.close()
s.getpeername() 返回远程地址
s.getsockname() 返回本地地址
s.setsockopt(level,optname,value)
s.getsockopt(level,optname[,buflen])
s.settimeout(timeout)
s.gettimeout()
s.fileno() 返回套接字的文件描述符
s.setblocking(flag) flag为False 为非阻塞式
s.makefile() 创建一个与该套接字相关联的文件

PYTHON INTERNET 模块：
1. HTTP 网页访问
2. NNTP 阅读和张贴新闻文章
3. FTP 文件传输
4. SMTP 发送邮件
5. POP3 接收邮件
6. IMAP4 获取邮件
7. TELNET 命令行
8. GOPHER 信息查找

基础语法

基本数据类型

Number

字符串

bool类型

列表

元组

集合

字典

bytes类型

python 数据类型转换

python3数据类学转换

python3 解释器

注释

python3 运算符

算术运算符

比较运算符

赋值运算符

位运算符

逻辑运算符

成员运算符

身份运算符

数字

数字函数

随机函数

三角函数

数学常量

python3 字符串

转义字符

字符串运算

字符串格式化

在八进制数前显示0 十六进制前显示’0x’

f-string

字符串的内建函数

列表

元组

修改元组

删除元组

元组运算符

元组的内置函数

元组是不可变的

字典

创建字典

访问字典里的值

修改字典

删除字典元素

字典键的特性

字典的内置函数&方法

集合

集合的创建

集合的基本操作

集合内置方法

条件控制

循环语句

推导式

列表推导式

字典推导式

集合推导式

元组推导式

迭代器和生成器

创建一个迭代器

StopIteration 异常

生成器

函数

定义函数

参数传递

参数

匿名函数

return语句

强制位置参数

lambda 函数

装饰器

带参数的装饰器

类装饰器

数据结构

将列表当作栈来使用

将列表当作队列来使用

列表推导式

嵌套列表解析

del语句

正则表达式修饰符可选标志