Python
1
- 以下划线开头的标识符是有特殊意义的。
- 不能直接访问的类属性，需通过类提供的接口进行访问，不能用
from xxx import *而导入。
- 不能直接访问的类属性，需通过类提供的接口进行访问，不能用
2
-
以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如
__init__()代表类的构造函数。 -
所有 Python 的关键字只包含小写字母
基础语法
-
缩进：缩进相同的代码块：代码组。
- if，while，def，class以关键字开头，冒号结束。
-
注释：
- python中单行注释采用 # 开头。
python 中多行注释使用三个单引号**(‘’')**或三个双引号(“”")。
- python中单行注释采用 # 开头。
-
多行语句
#\: |
基本数据类型
- 变量必须赋值。
- 变量没有类型，类型是指变量所指的内存中对象的类型。
- 基本数据类型
- 不可变类型：Number，String，Tuple
- 可变数据类型：List，Dictionary，Set
- type(a)：查看变量所指的对象的类型，子类不是父类类型。
isinstance(a,int)：子类也算父类类型。bool是int子类
Number（数字）
-
整数
int，布尔型bool，浮点数 float，复数complex` -
整型只有int，长整型。
-
双操作算数运算符
-
/ ：除法：浮点数
-
// ：除法：取整。// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
7//2
3
7.0//2
3.0
7//2.0
3.0 -
** ：乘方。
-
混合计算，整型会变成浮点数
-
海象运算符：
:=
#即一个变量名后跟一个表达式或者一个值，这个和赋值运算符 = 类似，可以看作是一种新的赋值运算符。
nums = [16, 36, 49, 64]
def f(x):
print('运行了函数f(x)1次。')
return x ** 0.5
print([f(i) for i in nums if f(i) > 5])
'''
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
[6.0, 7.0, 8.0]
'''
nums = [16, 36, 49, 64]
def f(x):
print('运行了函数f(x)1次。')
return x ** 0.5
print([n for i in nums if (n := f(i)) > 5])
'''
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
运行了函数f(x)1次。
[6.0, 7.0, 8.0]
''' -
位运算符
- &
- |
- ^
-
>>>>
-
逻辑运算符
-
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。 or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。 not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
-
-
成员运算符：
- in
- not in
-
身份运算符
- is：比较两个变量标识符是否引用自同一个对象
- is not：两个变量标识符引用自不同的对象。
- id() 函数用于获取对象内存地址。
-
数学函数
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的小数部分与整数部分，元组。两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
round(x [,n]) 返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x) 返回数字x的平方根。 -
随机函数
import random
random.choice( seq )
#seq:list，string，tupleimport random
random.randrange ([start,] stop [,step])
#randrange() 方法返回指定递增基数集合中的一个随机数，基数默认值为1。
random.randrange(1,100,2)
random.randrange(100)import random
random.random()
#random() 方法返回随机生成的一个实数，它在[0,1)范围内。import random
random.seed ( [x] )
#我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。import random
random.shuffle (lst )
#shuffle() 方法将序列的所有元素随机排序。
'''
因为 random.shuffle 具有破坏性，需要每次都重置列表。
下列代码才可以得到相同的随机排序列表
'''
#调用random.shuffle函数时保存原序列变量防止被破坏。
SEED = 10
original_list = ['list', 'elements', 'go', 'here']
random.seed(SEED)
my_list = original_list[:]
random.shuffle(my_list)
print("RUN1: ", my_list)
random.seed(SEED)
my_list = original_list[:]
random.shuffle(my_list)
print("RUN2: ", my_list)import random
random.uniform(x, y)
'''
x -- 随机数的最小值，包含该值。
y -- 随机数的最大值，包含该值。
'''
import random
round(random.uniform(5, 10), 2)
#两位浮点数 -
三角函数
import math
math.acos(x)
math.asin(x)
math.atan(x)
math.atan2(x)
#返回弧度值
math.sin(x)
math.cos(x)
math.tan(x)
#弧度x的三角函数值
math.hypot(x，y)
#返回欧几里得范数sqrt(x*x + y*y)。
math.degrees(X)
#弧度转换为角度
math.radians(x)
#角度转换为弧度
-
String（字符串）
-
单引号与双引号作用相同
-
反斜杠 \ 可以用来转义，使用r可以让反斜杠不发生转义。。 如
r"this is a line with \n"则\n会显示，并不是换行。 也可用作续行符。 -
字符串可以用 + 运算符连接在一起，用 ***** 运算符重复.
-
in成员运算符：如果字符串中包含给定的字符返回True，
'H' in a输出结果 True -
not in 成员运算符:如果字符串中不包含给定的字符返回True
-
没有字符类型，字符串不能改变
-
字符串的截取的语法格式如下：
变量[头下标:尾下标:步长]，从左往右为0，从右往左为-1. -
print(str[0:-1])左闭右开 ，输出第一个到倒数第二个的所有字符。，默认换行，不换行：加上end = "" -
输入：
input("输入： "); |
-
%格式化输出 ：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) -
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
-
f-string：字面量格式化字符串
- 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例:
f"hello{name}"= “hello+name的串值”
- 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例:
-
格式化输出format函数：
"{},{}".format("str1","str2"),
"{0},{1},{0}".format("str1","str2"),
#索引指定
"{name},{sex}".format(name="",sex="")、
#变量名指定-
数字格式化
{:.2f} #保留小数点两位
{:+.2f} #带符号保留小数点后两位
{:0>2d} #数字宽度为2 左边填充0
{:x<2d} #数字宽度为2 左边填充x
{:^2d} #中间对齐
{:,} #以逗号分割数学格式
{:.2%} #百分比格式，保留小数点两位
{:.2e} #指数计数法，保留小小数点两位
#进制数
{:b} #二进制
{:d} #十进制
{:o} #八进制
{:x} #十六进制
{:#x} #十六进制小写，数字前加0x
{:#X} #十六进制大写，数字前加0X -
可以使用大括号转义大括号。
-
'''和"""注释符的注释的变量可以不用考虑特殊字符的转义直接使用。 -
设置字典参数：
"{key}".format(**site)
设置列表参数："{0[0]},{0[1]}".format(list)
-
可在{}中使用 !a,!s.!r对输出的值类型进行转换
-
字符串内置函数：
str.capitalize()
#将字符串第一个字母转换为大写，其余字符会转换为小写str.center(width [,fillchar])
#返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
#width ：字符串宽度
#fillchar :填充字符，只能是单个字符str.count(sub, start=0, end=len(string))
#返回子字符串出现的次数
#sub:搜素的字符
#start：开始搜索的位置，默认为0
#end结束搜索的位置，默认为最后一个字符串str.decode(encoding = "utf-8",errors = "strict")
#已指定的编码格式解码bytes对象，默认为utf-8
#encoding 使用的编码方式
#errors:设置不同的错误处理方案，默认为strict，编码错误会引起一个UnicodeError。其他值还有：ignore,"replace","xmlcharrefreplace","backslashreplace"，还可以通过codecs.register_error()注册任何值。
str.encode()
#decode对应函数,返回编码后的字符串，是一个bytes对象str.endswith(suffix[,start[,end]])
#判断字符串是否以指定的后缀结尾
'''
suffix 一个字符串或一个元素
start 开始位置
end 结束位置
'''str.expandtabs(tabsize=8)
'''
expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，
如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
'''str.find(str,beg=0,end=len(string))
str.rfind(str,beg = 0, end=len(string))
'''
str指定的字符串
beg开始索引，默认为0
end结束索引，默认为字符串长度
rfind从右边开始找
包含字符串 则返回第一个匹配的开始的索引值，否则返回-1
'''str.index(str,beg=0,end=len(string))
str.rindex(str,beg=0,end=len(string)
'''
rindex从右边开始找
与find方法类似，str不在会报一个异常
'''str.isalnum()
'''
检测字符串是否由 字母 或 数字 组成（汉字也可以）
'''
str.isalpha()
'''
检测字符串是否只由字母或文字组成
'''
str.isdigit()
str.isnumeric()
'''
检测字符串是否只有数字
isnumeric方法 数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
指数类似 ² 与分数类似 ½ 也属于数字。
'''
str.islower()
'''
检测字符串中字符是否都为小写
'''
str.isspace()
'''
检测字符串是否含有空格
'''
str.istitle()
'''
字符串中所有单词首字母是否为大写
'''
str.isupper()
'''
字符串中所有字母是否都为大写
'''
str.isdecimal()
'''
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
'''
str.join(sequence)
'''
以str为连接符将序列 连接成字符串
'''len(string)
'''
参数可以是序列，string，bytes，tuple，lsit，range等或集合 dict，set
'''str.ljust(width [,fillchar])
str.rjust(width [,fillchar])
'''
width 指定字符串长度
fillchar 填充字符，默认为空格
'''str.lower()
str.upper()
str.swapcase()
str.title()
'''
大小写转化
title函数将首个字母转换为大写，非字母后的第一个字母会变成大写（单词匹配）
'''str.lstrip([chars])
str.rstrip([chars])
str.strip([chars])
'''
lstrip将字符串左边的字符串 chars截掉，默认为空格，从左到右匹配，不符合则停止。
rstrip将字符串末尾 指定的字符串截掉
strip移除字符串头尾指定的字符，默认为空格，只能是开头和末尾，且包含字符就删除，不必意义匹配。
'''str.maketrans(intab ,outtab)
'''
创建字符映射转换表
一个参数：dict映射
两个参数
intab 要替换的字符串
outtab 映射字符的字符串
两字符串长度需要一样长
三个参数
第三个参数的字符会被删除，其余字符映射成none
'''
str.translate(table [,delete])
'''
table：翻译表，通过maketrans()方法转换而来
delete：字符串中要过滤的字符列表，字符串中没有此参数，bytes有或bytesarray有
'''max(str)
min(str)
'''
返回字符串中最大与最小值
'''str.replace(old ,new[,max])
'''
old 替换的旧字符串
new 替换的新字符串
max 替换的最大次数
'''str.split(str="",num=string.count(str))
'''
str 分割字符，默认为所有的空字符，包含空格，换行，制表符等
num 分割次数，默认为-1，分割所有
返回字符串列表
'''
str.splitlines([keepends])
'''
按照行 "\r,\r\n,\n"进行分割，返回一个包含隔行作为元素的列表，参数keepends决定是否保留换行符,默认为false
'''str.startwith(substr,beg=0,end=len(string))
'''
substr：子字符串
beg：检测其实位置
end：结束位置
检测是否以指定字符串开头。
'''str.zfill()
'''
返回指定长度的字符串，源字符串右对齐，填充0
'''
内置函数
append()
pop()
List列表
-
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
-
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：变量[头下标:尾下标:步长]，若步长为负数，则表示逆向读取。
-
内置函数
list.append(obj)
'''
更新
为浅拷贝，只拷贝了父对象，子对象仍只是引用。可通过id()函数返回变量唯一标识确定是否指向同一变量。
>>>alist = []
>>> num = [2]
>>> alist.append( num )
>>> id( num ) == id( alist[0] )
True
如果需要深拷贝：使用list.append(copy.deepcopy(num))
'''
list.extend(seq)
'''
list，tuple，set，dict(仅存key)
'''
list.insert(index,obj)
'''
index：插入索引的值
obj：插入对象
插入为浅拷贝。
'''
list.pop([index = -1])
'''
index 可选参数，移除所选元素。默认返回最后一个值
'''
del list[num]
'''
删除元素
'''
list.clear()
'''
清空。
'''
list.copy()
'''
浅复制
'''
list.remove(obj)
'''
移除第一个匹配项
'''
list.index(x [,start [,end]])
'''
x:查找元素
start：起始位置
end：结束位置
返回索引值，未找到则抛出异常
'''
list.count(obj)
'''
统计某个元素在列表出现的次数
'''
list.reverse()
'''
反向排序
'''
list.sort(key = None,reverse = False)
'''
key：用来比较的元素，只有一个参数
reverse：True降序，默认False升序。
'''-
直接赋值：对象引用
-
浅拷贝：
copy(): 只拷贝父对象，不会拷贝对象内部的子对象 -
深拷贝：
copy.deepcopy(): 完全拷贝父类对象及其子对象import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )
'''
结果
('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])
('d = ', [1, 2, 3, 4, ['a', 'b']])
'''len(list) #长度
max(list) #最大值
min(list) #最小值
list(seq) #元组转化为序列
list1 + list2 #列表拼接
list * 2 #列表重复
in #检查元素
for x in list #迭代
-
Tuple元组
-
元素不能修改，使用小括号。
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。 -
创建元组
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号 -
序列：sequence：List，Tuple，String
-
运算同列表
Dict字典
- Dict为无序的对象集合,List为有序的对象集合。
- 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2, key3 : value3 }
-
键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
-
访问字典里的值
把相应的键放入到方括号中，如下实例:dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}
print ("dict[‘Name’]: ", dict[‘Name’])
print ("dict[‘Age’]: ", dict[‘Age’]) -
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例 -
字典为映射类型，元素为键值对。
#添加 删除
ditc[key] = value
del dict[key]
dict.clear() -
内置函数
dict.clear()
dict.copy()
'''
浅复制
'''
dict.update(dict2)
'''
将dict2添加到dict中
'''
dict.fromkeys(seq [,value])
'''
以seq为字典键值序列
value为序列对应的值，默认为None
'''
dict.get(key,default=None)
dict.setdefault(key,default=None)
'''
返回指定key的值，不存在则返回default值
区别：
不存在时，setdefault会返回默认值并修改
'''
#in 操作符判断键值是否存在
dict.items()
dict.keys()
dict.values()
'''
返回视图对象，视图对象不可修改，为只读。
items返回一个key，value对。
用于遍历：
dict = {'Name': 'Runoob', 'Age': 7}
for i,j in dict.items():
print(i, ":\t", j)
'''
dict.pop(key [,default])
'''
删除key对应值，不存在则返回default值
默认删除最后一个元素
'''
dict.popitem()
'''
删除返回最后一对key/value值
'''
Set集和
-
基本功能：用于成员测试和删除重复元素。
-
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。a：集合中不重复的值。
a - b # 差集： 集合a中包含而集合b中不包含的元素
a | b # 并集 ：集合a或b中包含的所有元素
a & b # 交集：集合a和b中都包含了的元素
a ^ b # 不同时包含于a和b的元素 -
添加：
s.add( x )；
#还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
#x可以为元素或集合。
#移除元素：
s.remove( x )
s.clear()
s.discard( x )
#x可以为元素或集合。
s.copy()
#浅复制
s.difference(set1,set2...)
#集合的差集
s.difference_update(set)
#移除两级中相同的元素
s.intersection(set1,set2..)
#返回集合的交集
s.intersection_update(set1,set2..)
#移除原集合中不重叠的元素
s.isjoint(set)
#判断两集合是否有相同元素
s.issubset(set)
#判断s是否为子集
s.isuperset(set)
#判断时候为父集
s.pop()
#随机删除一个元素
s.symmetric_difference(set)
#返回两个集合中不重复的元素
s.symmetric_difference_update()
#删除两个集合相同的元素，并拼接另一个集合中不同的元素
s.union()
#返回两个集合的并集
类型转换函数
class int(x, base=10) |
class float(x) |
class str(object='') |
repr(object) |
eval(expression[, globals[, locals]]) |
tuple(iterable) |
list(seq) |
class set([iterable]) |
class dict(**kwarg) |
|
chr(x) |
''' |
|
|
Python 解释器
-
Python 解释器可不止一种哦，有 CPython、IPython、Jython、PyPy 等。
顾名思义，CPython 就是用 C 语言开发的了，是官方标准实现，拥有良好的生态，所以应用也就最为广泛了。
而 IPython 是在 CPython 的基础之上在交互式方面得到增强的解释器（http://ipython.org/）。
Jython 是专为 Java 平台设计的 Python 解释器（http://www.jython.org/），它把 Python 代码编译成 Java 字节码执行。
PyPy 是 Python 语言（2.7.13和3.5.3）的一种快速、兼容的替代实现（http://pypy.org/），以速度快著称。
-
在交互模式中，最后被输出的表达式结果被赋值给变量 _
-
此处， _ 变量应被用户视为只读变量。
程序
end 关键字将输出到同一行，也可在输出末尾添加字符
eg：print(a,end = ',');
##条件控制
if con1:
state 1
elif con2:
state 2
else:
state 3
python 没有switch语句。
条件控制
#if 语句格式，相同缩进代表一个语句块，无switch 语句 |
#循环语句，python没有do ，while语句和自增表达式 |
迭代器
-
访问集合元素的一种方式。
-
迭代器是一个可以记住遍历位置的对象。且只能前进不会后退。
-
字符串，列表，元组对象都可以创建迭代器，两个基本方法：
it = iter(list)，#创建迭代器对象。list为一个支持迭代的集合对象
next(it)。 #输出迭代器下一个元素。
#也可用for语句进行遍历：
for i in it：
print(i,end = ' ');
#使用next遍历：
while True:
try:
print(next(it))
except StopIteration:
sys.exit()
#使用StopIteration异常来判断迭代完成，需要捕获异常。 -
创建自己的迭代器
-
若要将一个类当作迭代器使用，需要实现两个方法：
-
__iter__():返回一个特殊的迭代器对象。(此对象中实现了__next__()方法并通过StopIteration来标识完成迭代) -
__next__()：返回下一个迭代元素。class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
if x <= 5:
return x
else:
raise StopIteration -
迭代器可用for循环 迭代：
for x in MyNumbers():
print(x) -
-
-
生成器
-
使用了
yield的函数被称为生成器（generator）。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
-
函数
def name(argument): |
- python中类型属于对象，变量没有类型，变量仅是对象的引用。
- strings,tuples,numbers是不可更改对象，list，dict是可更改对象。
- 可变类型：List，dict，set。
参数调用：
-
可变类型：类似传值调用，不改变对象本身。
-
可变类型：类型引用调用，可以改变引用的对象。
-
传入参数类型：
-
必须参数：数量和顺序必须一致。
-
关键字参数：使用参数名指定参数，顺序可以不一致。
-
默认参数：若没有传入参数，使用函数定义时使用的默认参数。
-
变长参数：调用时传入比声明时更多的参数。
def func(a,*var_tuple):
state;
#传入*后的参数以元组的形式存储。
def func(b,**var_dict):
state; #传入未命名的参数以字典形式存储。
#字典传参数时：用等号连接键与键值。
#调用：
func(10, a = 1,b = 2);
#单独出现*
def func(a,b,*,c):
state;
#* 后的参数必须使用关键字传入。匿名函数：lambda
-
-
lambda只是一个表达式，函数体比def简单。
-
lambda函数有自己的命名空间，且不能访问参数列表之外或全局变量的参数。
-
主体是一个表达式，而不是一个代码块。
func_name = lambda arg1,arg2：expression
-
目的：小型函数不用占用栈内存从而增加运行效率。
-
py3.8
- 强制位置参数：/前的参数只能指定位置参数。
- 关键字参数：*后的参数必须使用关键字。
python数据结构
-
列表：
- list.append(x) 末尾添加元素
- list.extend(L)=（a[len(a):] = L)
末尾添加指定列表扩展原有列表 - list.insert(i,x) 在索引i前面元素插入x
- list.remove(x) 删除列表中第一个x，若没有，则返回错误。
- list.pop([i]) 从索引i删除元素并返回，若无参则默认最后一个元素。
- list.clear() 清除列表元素。
- list.index(x) 返回列表中x的索引。
- list.count(x) 返回列表中x出现的次数。
- list.sort() 排序
- list.reverse() 反排
- list.copy() 浅复制
-
列表使用：
-
堆栈：后入先出：list.append()与list.pop() 栈顶在末尾。
-
队列：先进先出：list.append()与list.pop(0)或者
from collections import deque将列表转换为队列a = deque(List)调用a.popleftfrom collections import deque
queue1 = deque(list1)
queue1.append();
queue1.popleft();
-
-
列表推导式：将某个操作应用于列表(序列)的每一个元素，来创建新的列表，或者根据确定的判断条件创建子序列。如果希望推导出一个元组，则必须使用括号（也可通过for range(len(list)) 来遍历改变列表。
-
[表达式(可以调用函数 for x in list if x >= 0]或()。eg: ver = [1,2,3]
ver1 = [x**2 for x in ver];
ver2 = [x/2 for x in ver if x > 1]
ver3 = (x for x in ver)
对双列表操作，双for语句前为外层，后为里层。 -
多维列表解析：matrix.py
#矩阵转置：
#解法一：列表表达式
matrix1 = [ [row[i] for row in matrix] for i in range(len(matrix[0]))]
#外层循环为列数
#内层循环为每一行。
#解法二：双循环
transport = []
for i in range(len(matrix[0])):
matrix_row = []
for row in matrix:
matrix_row.append(row[i])
transport.append(matrix_row)
print(transport) -
del语句：依照索引删除元素，因此可以切割列表 del a[0:4]:删除0-3元素。也可删除实体变量。
-
输入时元组是若干逗号分隔的值组成。eg： t = 1，3，4
-
集合：无序不重合的元素的集合。
a^b：在a或b中元素，但不同时在a和b中的元素。
集合也支持推导式。 -
字典：支持推导式
{x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
dict(sape=4139, guido=4127, jack=4098)
{‘sape’: 4139, ‘jack’: 4098, ‘guido’: 4127} -
字典遍历：
-
在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来。
for x,v in dict.items() #关键字，键值
-
序列遍历时用enumerate()函数同时得到：
for i ,v in enumerate(list,tube) #索引，值
-
遍历两个或更多序列：使用zip()
for a,b in zip(list1/tube,list2/tube):
print("{0},{1}".format(a,b)) -
反向遍历一个序列：使用reversed()
for i in reversed(list/tube):
-
按顺序遍历序列：使用sorted()
for i in sorted(list/tube):
-
模块
-
一个pyhton文件叫一个模块
-
一个模块只会被导入一次。
-
python解释器怎么样找到需要导入的包呢，这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。
这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。路径存在sys.path中。
若需要导入不同文件的包：sys.path.append();- 在目录创建一个
__init__.py
-
导入模块：遇到import语句，如果在sys.path路径中，则会被导入
import module #只导入了模块 |
from modname import name1[, name2[, ... nameN]]/from module import * |
if __name__ == "__main__": |
dir(模块)：#模块中所有名字。返回字符列表 |
-
包管理:
import package时，根据sys.path中的路径来寻找改包及其子目录。只有含有 `__init.py__`才会认作是一个包。
Test1与Test2
1. 同一包：
from package.module import func #导入特定函数
import package.moduel #导入模块，不能直接导入函数
2. 子目录包模块：添加__init__.py
from package.module import func
import package.module
3. 父级目录模块或同级包目录模块：__init__.py
sys.path.append(r"父目录的绝对路径")
#sys.path.append(os.path.dirname(os.path.dirname(__file__))) ：相同的父级目录
from package.module import func
importpacka.module__init.py__文件中定义__all__列表变量，在使用from package import * 时回到入列表中的文件名。Windows不区分大小写。
输入与输出
-
标准输出文件：
sys.stdout -
格式化输出(参见字符串），将输出值转换为字符串使用repr()或str()函数
-
str()： 函数返回一个用户易读的表达形式。会转义特殊字符
-
repr()： 产生一个解释器易读的表达形式。不会转义特殊字符，参数可为任意对象。
-
repr().rjust/ljust/center等方法对齐，zfill()在字符左侧填充0 -
输入：input()输入一行文本：标准输入
-
文件读写：
file = open(filename,model);
#open返回一个file对象
```
- filename：包含了你要访问的文件名称的字符串值。
- mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- r：只读，指针在开头
- r+：读写，指针在开头
- w：写，创建，指针在开头，覆盖
- w+：读写创建，指针在开头，覆盖
- a：追加写，创建，指针在末尾。
- a+：读写，创建，指针在末尾 -
文件对象的方法
-
f.read(size),读取一定数目的数据，要先打开文件。size忽略或为负数则读取全部。读取内容将会被返回。 -
f.readline(size)从文件中读取单独的一行。包含换行符。 -
f.readlines(sizehint)从文件中读取所有行包含换行符’\n’,sizehint:指定长度字节数，返回列表。#使用for读取每一行
file.open("",r)
for line in file:
print (line)
file.close()
f.write(string)
'''
文件关闭或缓冲区刷新前，字符串内容存储在缓冲区内，还未写入文件以b 方式打开，写入参数需要转换为bytes类型
'''
#返回写入的字符数,写入的不是字符，先用str()函数转换。
```python
f.tell()
#返回当前文件对象所处位置，返回文件开头算起的字节数
f.seek(offset,from_what) |
-
pickle模块实现了序列化和反序列化
-
序列化：程序中运行的对象信息保存到文件中去，永久存储。
-
基本接口
pickle.dump(obj,file,[,protocol])
pickle.load(file)
#file 类文件对象
#protocol 序列化模式：默认为0(ASCII协议)rotocol的值还可以是1和2（1和2表示以二进制的形式进行序列化。其中，1是老式的二进制协议；2是新二进制协议）。
-
-
常用文件函数
f.flush()
'''
刷新缓冲区，不需要被动等待输出缓冲
文件关闭会自动刷新缓冲区
'''
f.fileno()
'''
返回文件描述符：Linux/C底层系统调用文件参数
'''
f.isatty()
'''
检测文件是否连接到一个终端设备
'''
f.truncate([size])
'''
truncate() 方法用于从文件的首行首字节开始截断，截断文件为 size 个字节，无 size 表示从当前位置截断；
'''
f.writelines(seq)
'''
向文件中写入字符串序列，迭代对象，如列表，需要自定义换行符
seq = ["菜鸟教程 1\n", "菜鸟教程 2"]
f.writelines( seq )
'''
OS 模块
os.access(path,mode) |
错误与异常处理
-
使用try except语句：
-
-
流程：
-
try 子句
-
try子句中没有异常，跳过except语句
-
try子句中有异常，则跳过剩余部分，异常类型与except后相符才执行，except可以有多个异常，以元组形式
-
没有匹配的except将传递到上层try中
-
最后一个except子句可以忽略名字，当作通配符使用。
-
esle子句在try 子句没有任何异常时执行：将部分一些意想不到的没有被捕获的异常语句放入此中
-
finally子句在任何时候都会执行
try：
except(OSError,ValueError)
except:
else:
finally:
-
-
抛出异常：
raise [Exception,[,args[,traceback]]]
'''
必须抛出一个异常的实例 或者异常类（Exception 子类）
'''
Python 面向对象
-
类变量：整个实例化的对象中是公用的。类变量在函数体外。通常不作为实例变量使用
-
实例变量：用self修饰的变量\
-
__init__()为构造方法 -
类中的方法 都有一个默认第一个 参数：类的实例变量，一般命名为self
class <Name>:
statement1
statement2
def __init__(self):
def func(self):
-
python支持多继承,：集成所有父类的属性和方法。
class child(parent1,parent2):
statement1
statement2 -
多继承时需要注意括号中父类的顺序，如果父类中有同名的方法，子类中未指明时，python从左到右搜索
-
python 继承会继承父类的构造方法，有以下情况
-
重写构造方法，执行子类的构造方法
-
不重写构造方法，默认调用父类构造方法
-
重写构造方法后显式 调用父类构造方法
super(Child,self)super(type [,object-or-type])
'''
type：子类
object-or-type：子类对象
'''
'''
python3可直接使用super()代替
'''
-
-
可以使用
parent.func调用父类方法或者super().func -
在类中以类名调用方法 必须有self参数，在类外 实例化后调用不用传self参数。
-
私有属性与方法：
- __ 双下划线开头的方法与属性为私有属性，不能在外部访问。
-
类的专有方法：
def __str__(self):
'''
必须return一个字符串类型，作为实例对象的字符串描述。
直接显示类 变量调用的是__repr__(self)函数
__repr__ = __str__
'''
n
def __getitem__(self，n):
'''
获取容器中元素:可以使用 索引获取类容器中值：
n为索引值
class Container():
def __getitem__(self,n):
return n**2;
con = Container()
print(con[5])
'''
def __getattr__(self,attr):
'''
增加动态属性，防止访问类中不存在的属性出错
只有访问不存在的属性才会调用此方法
attr为不存在属性名，若方法中也未定义此attr，则返回不None
'''
def __call__(self,[]):
'''
对实例进行调用
''' -
类与对象相关的方法：
issubclass(class,classinfo)
'''
class是否为classinfo的子类
'''
hasattr(object,name)
getattr(object,name,[,default])
setattr(object,name,[,default])
delattr(object,name)
'''
分别为查找，获取，设置，删除类中属性
object：类的实例化对象
name：属性名字符串
default：默认值
getattr()若属性不存在：
未设置默认值则抛出AtrributeError异常
设置了默认值则返回默认值
setattr():属性不存在则新建属性且复制
delattr():属性不存在则抛出AttrubuteError异常。
'''
__len__(): #获得长度
__cmp__(): #比较运算
__call__(): #函数调用
__add__(): #加运算
__sub__(): #减运算
__mul__(): #乘运算
__truediv__(): #除运算
__mod__(): #求余运算
__pow__(): #乘方
命名空间与作用域
-
命名空间：名称到对象的映射，一般采用字典形式
- 内置命名空间：内置名称
- 全局命名空间：模块中的名称
- 局部命名空间：函数中定义的名称
-
从下到上依次查找，无法从外部中访问内部命名空间对象。
-
global 与 nonlocal关键字：
global a
'''
在函数内部修改外部的全局变量
a 为全局变量
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
'''
nonlocal a
'''
在嵌套函数中 修改外层函数中的变量
a为外层函数变量
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
'''
正则表达式
-
功能：
- 测试字符串内的模式
- 替换文本
- 基于模式匹配提取子字符串
-
普通字符 与 特殊字符（元字符） 组成
-
普通字符：没有显式指定为元字符的可打印与不可打印的所有字符
- [ABC] : 匹配中括号中的所有字符
- [^ABC]：匹配除了中括号中的所有字符
- [A -Z]：匹配A-Z区间中的字符
- . :匹配除换行符 \r,\n之外的所有单个字符
- [\s\S] ：匹配所有，\s为所有空白符，\S为非空白符
- [\w] :匹配字母，数字，下划线。
-
非打印字符：
-
\cx 匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。 \f 匹配一个换页符。等价于 \x0c 和 \cL。 \n 匹配一个换行符。等价于 \x0a 和 \cJ。 \r 匹配一个回车符。等价于 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。 \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 \t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
-
-
特殊字符：
-
特别字符 描述 $ 匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 $。 ( ) 标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。 * 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。 + 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。 . 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。 [ 标记一个中括号表达式的开始。要匹配 [，请使用 [。，匹配字符列表中的单个字符 ? 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。 \ 将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。‘\n’ 匹配换行符。序列 ‘\’ 匹配 “”，而 ‘(’ 则匹配 “(”。 ^ 匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。 { 标记限定符表达式的开始。要匹配 {，请使用 {。
-
-
限定符：指定表达式中 一个给定的组件 出现多少次 才能满足匹配，总共有六种：
-
字符 描述 * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。 + 匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。 ? 匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。 {n} n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。 {n,} n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。 {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。 -
’ * ‘ 与 ‘ +’ 都是贪婪的，会尽可能匹配较多的元素，加上 ‘ ？’ 会变成最小匹配
-
-
定位符 ：指定正则表示的位置：固定到行首或者行尾。单词首，或者单词尾
-
字符 描述 ^ 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与 \n 或 \r 之后的位置匹配。 $ 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与 \n 或 \r 之前的位置匹配。 \b 匹配一个单词边界，即字与空格间的位置。 \B 非单词边界匹配。 -
定位符 与 限定符不能同时使用
-
-
选择：
-
（）将所有选择项括起来，选择项之间使用 |
-
() 会将匹配的值保存起来，可通过索引进行查看，副作用存在相关匹配会被缓存，使用
?:消除这种副作用 -
其他非捕获元 ：
?=?!-
exp1(?=exp2)：查找 exp2 前面的 exp1。
- ```
(?<=exp2)exp1:查找exp2之后的exp1 -
exp1(?!exp2):查找后面不是exp2的exp1
- ```
(?<!exp2)exp1:查找前面不是exp2的exp1
-
-
-
反向引用：查找文本中两个相同的相邻单词的匹配项的能力
-
使用（）会使匹配项存储到缓冲区，编号从1开始，最多存储99个，每个缓冲区使用 \n 进行访问，n为一个表示特定缓冲区的十进制数
var str = "Is is the cost of of gasoline going up up";
var patt1 = /\b([a-z]+) \1\b/ig;- \b 表示单词边界，\1 表示缓冲区中刚匹配的 括号中的字符串
- \i: 不区分大小写
- g：尽可能多的匹配项
var str = "http://www.runoob.com:80/html/html-tutorial.html";
var patt1 = /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/;
arr = str.match(patt1);str.match(patt1)返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。- 第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。
- 第二个括号子表达式捕获地址的域地址部分。子表达式匹配非 : 和 / 之后的一个或多个字符。
- 第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。
- 最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。
-
-
修饰符：标记不写在正则表达式里，标记位于表达式之外：
-
/pattern/flag
-
修饰符 含义 描述 i ignore - 不区分大小写 将匹配设置为不区分大小写，搜索时不区分大小写: A 和 a 没有区别。 g global - 全局匹配 查找所有的匹配项。 m multi line - 多行匹配 使边界字符 ^ 和 $ 匹配每一行的开头和结尾，记住是多行，而不是整个字符串的开头和结尾。 s 特殊字符圆点 . 中包含换行符 \n 默认情况下的圆点 . 是 匹配除换行符 \n 之外的任何字符，加上 s 修饰符之后, . 中包含换行符 \n。
-
-
元字符
-
字符 描述 \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，‘n’ 匹配字符 “n”。‘\n’ 匹配一个换行符。序列 ‘\’ 匹配 “” 而 “(” 则匹配 “(”。 ^ 匹配输入字符串的开始位置，包含整个字符文本。(需要按行匹配的话)如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。 $ 匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。 * 匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。 + 匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。 ? 匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 。? 等价于 {0,1}。 {n} n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。 {n,} n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。 {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。 ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，‘o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。 . 匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用像"(.|\n)"的模式。 (pattern) 匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘(’ 或 ‘)’。 (?:pattern) 匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。 (?=pattern) 正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”，但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 (?!pattern) 正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。 (?<=pattern) 反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"`(?<=95 (?<!pattern) 反向否定预查，与正向否定预查类似，只是方向相反。例如"`(?<!95 x|y 匹配 x 或 y。例如，‘z|food’ 能匹配 “z” 或 “food”。‘(z|f)ood’ 则匹配 “zood” 或 “food”。 [xyz] 字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。 [^xyz] 负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、‘l’、‘i’、‘n’。 [a-z] 字符范围。匹配指定范围内的任意字符。例如，‘[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。 [^a-z] 负值字符范围。匹配任何不在指定范围内的任意字符。例如，‘[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。 \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 \B 匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 \cx 匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。 \d 匹配一个数字字符。等价于 [0-9]。 \D 匹配一个非数字字符。等价于 [^0-9]。 \f 匹配一个换页符。等价于 \x0c 和 \cL。 \n 匹配一个换行符。等价于 \x0a 和 \cJ。 \r 匹配一个回车符。等价于 \x0d 和 \cM。 \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。 \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。 \t 匹配一个制表符。等价于 \x09 和 \cI。 \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。 \w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]'。 \W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。 \xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，‘\x41’ 匹配 “A”。‘\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。 \num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，‘(.)\1’ 匹配两个连续的相同字符。 \n 标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。 \nm 标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。 \nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。 \un 匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。
-
-
优先级
-
运算符 描述 \ 转义符 (), (?:), (?=), [] 圆括号和方括号 *, +, ?, {n}, {n,}, {n,m} 限定符 ^, $, \任何元字符、任何字符 定位点和序列（即：位置和顺序） | 替换，“或"操作 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food”。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。 -
常见实例：
-
用反斜杠将它转义：
[\-]
-
将连字符放在中括号列表的开始或结尾。下面的表达式匹配所有小写字母和连字符：
[-a-z]
[a-z-] -
创建一个范围，在该范围中，开始字符值小于连字符，而结束字符值等于或大于连字符。下面的两个正则表达式都满足这一要求：
[!--]
[!-~] -
正则表达式 描述 /\b([a-z]+) \1\b/gi 一个单词连续出现的位置。 /(\w+)://([^/:]+)(:\d*)?([^# ]*)/ 将一个URL解析为协议、域、端口及相对路径。 /^(?:Chapter|Section) [1-9][0-9]{0,1}$/ 定位章节的位置。 /[-a-z]/ a至z共26个字母再加一个-号。 /ter\b/ 可匹配chapter，而不能匹配terminal。 /\Bapt/ 可匹配chapter，而不能匹配aptitude。 /Windows(?=95 |98 |NT )/ 可匹配Windows95或Windows98或WindowsNT，当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。 /^\s*$/ 匹配空行。 /\d{2}-\d{5}/ 验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。 /<\s*(\S+)(\s[^>])?>[\s\S]<\s*/\1\s*>/ 匹配 HTML 标记。
-
-
Python3 正则
-
re模块
-
re.match()函数:尝试从字符串起始位置匹配一个模式。re.match(pattern,string,flags)
'''
patterns：正则表达式
string：匹配的字符
flags：标志位
'''-
常见标志位：
-
修饰符 描述 re.I 使匹配对大小写不敏感 re.L 做本地化识别（locale-aware）匹配 re.M 多行匹配，影响 ^ 和 $ re.S 使 . 匹配包括换行在内的所有字符 re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
pattern.match(string ,pos = 0, endpos =len(string)
'''
pattern为compile函数的返回结果对象。
''' -
-
match函数的方法：
group()
'''
参数为：（）匹配到的子表达式索引值从1开始，0为匹配到的所有字符串
可在正则表达式中使用 : ?P<name> 指定括号子表达式的名字
'''
groups()
'''
返回包含所有组字符串的元组，从1到所有组
'''
start([group])
'''
返回指定group组分组字符串开始的位置
'''
end([group])
'''
返回指定group组分组字符串结束的位置，结束位置为开区间，因此最后索引值加1
'''
span()
'''
返回匹配到的字串在string中的位置（start，end）
左闭右开
''' -
re.search()方法：扫描整个字符串进行匹配re.search(pattern,string,flags=0)
pattern.search(string ,pos = 0, endpos =len(string) -
re.sub():re.sub(pattren,repl,string,count = 0,flags = 0)
'''
pattern"正则表达式
repl：替换的字符串，也可以是一个函数，repl为一个函数时：函数仅有一个match参数，返回值为替换的字符串。每成功匹配一次就调用一次该函数
string：目标字符串
count：替换次数，默认=0，所有。
''' -
compile函数：
re.compile(pattern，flags)
'''
编译一个正则表达式，生成一个pattern对象，有match与search函数。
''' -
findall()函数：在字符串中找到所有满足匹配的子串，并返回一个列表。re.findall(pattern,string,flags)
'''
match，search只匹配一次
findall匹配所有
'''
re.finditer(pattern,string,flags)
'''
与findall类似，找到所有字串并返回一个迭代器
迭代器中每个元素为match对象。
'''
re.split(pattern,string.maxsplit,flags)
'''
根据匹配的模式字符串进行分割。返回字符列表
pattern：正则表达式，没有括号列表中不会出现匹配的字符串，有括号列表中出现
string：源字符串
maxsplit：最多分割次数
''' -
python3中正则模式：
-
模式 描述 ^ 匹配字符串的开头 $ 匹配字符串的末尾。 . 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 […] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’ [^…] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 re* 匹配0个或多个的表达式。 re+ 匹配1个或多个的表达式。 re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 re{ n} 匹配n个前面表达式。例如，"o{2}“不能匹配"Bob"中的"o”，但是能匹配"food"中的两个o。 re{ n,} 精确匹配n个前面表达式。例如，"o{2,}“不能匹配"Bob"中的"o”，但能匹配"foooood"中的所有o。"o{1,}“等价于"o+”。"o{0,}“则等价于"o*”。 re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 a| b 匹配a或b (re) 匹配括号内的表达式，也表示一个组 (?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。 (?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。 (?: re) 类似 (…), 但是不表示一个组 (?imx: re) 在括号中使用i, m, 或 x 可选标志 (?-imx: re) 在括号中不使用i, m, 或 x 可选标志 (?#…) 注释. (?= re) 前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 (?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。 (?> re) 匹配的独立模式，省去回溯。 \w 匹配数字字母下划线 \W 匹配非数字字母下划线 \s 匹配任意空白字符，等价于 [\t\n\r\f]。 \S 匹配任意非空字符 \d 匹配任意数字，等价于 [0-9]。 \D 匹配任意非数字 \A 匹配字符串开始 \Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 \z 匹配字符串结束 \G 匹配最后匹配完成的位置。 \b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 \B 匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 \n, \t, 等。 匹配一个换行符。匹配一个制表符, 等 \1…\9 匹配第n个分组的内容。 \10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
-
-
Pandas + Numpy
-
dataFram
pandas.read_table()
pandas.read_csv()
//返回dataFram数据结构
df.index()
//行索引
df.columns()
//列索引
//构造dataFram时可通过index,columns参数设置对应的索引
df['列名']
'''
df还可以通过布尔值进行索引
'''
pd.merge(left, right, on=None, how='inner', left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None) |
-
Series
pandas.Series( data, index, dtype, name, copy)
'''
data：一组数据(ndarray 类型)。
index：数据索引标签，如果不指定，默认从 0 开始。
dtype：数据类型，默认会自己判断。
name：设置名称。
copy：拷贝数据，默认为 False。
''' -
Numpy
np.concatenate(array,axis=0)
'''
array为拼接的矩阵，axis为拼接的维度，0为第一维度，行拼接，列数需要一样
1为第二维度，列拼接，行需要一样。
'''
np.where(condition, x, y)
'''
满足条件(condition)，输出x，不满足输出y。
如果是一维数组，相当于[xv if c else yv for (c,xv,yv) in zip(condition,x,y)]
'''
np.where(condition)
'''
只有条件 (condition)，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。
'''
numpy.random.rand(d0,d1,…,dn)
'''
产生[0,1]，不包含1的随机数
dn代表数组的每个维度
'''
numpy.random.randn(d0,d1,…,dn)
'''
randn函数返回一个或一组样本，具有标准正态分布。
dn表格每个维度
返回值为指定维度的array
'''
numpy.random.permutation()
'''
Randomly permute a sequence, or return a permuted range.
随机产生一个序列，或是返回一个排列范围
If x is a multi-dimensional array, it is only shuffled along its
first index.
如果x是一个多维数组，它只会按照第一个索引洗牌
'''-
Numpy中主要对象为同种元素的多维数组
-
ndarray
'''
常见属性
'''
ndarray.shape:
#返回数组的形状. 备注:(n,)为一维数组, (m,1)为二维数组
ndarray.ndim:
#返回数组的维度
ndarray.size:
#返回数组包含的数据总数
ndarray.itemsize:
#返回数组储存的数据类型所占字节数
ndarray.nbytes:
#返回该数组占用的储存空间的总字节数
ndarray.T:
#返回该数组的转置
ndarray.real:
#返回该数组中每个元素的实部
ndarray.imag:
#返回该数组中每个元素的虚部
ndarray.dtype
#返回数组元素的类型'''
创建ndarray对象
'''
numpy.array(object, dtype = None, copy = True, order = None,ndmin = 0)
'''
序号 参数 描述说明
1 object 表示一个数组序列。
2 dtype 可选参数，通过它可以更改数组的数据类型。
3 copy 可选参数，表示数组能否被复制，默认是 True。
4 order 以哪种内存布局创建数组，有 3 个可选值，分别是 C(行序列)/F(列序列)/A(默认)。
5 ndim 用于指定数组的维度。
'''
import numpy
a=numpy.array([1,2,3])
#使用列表构建一维数组
print(a)
[1 2 3]
print(type(a))
#ndarray数组类型
<class 'numpy.ndarray'>
numpy.empty(shape, dtype = float, order = 'C')
'''
它接受以下参数：
shape：指定数组的形状；
dtype：数组元素的数据类型，默认值是值 float；
order：指数组元素在计算机内存中的储存顺序，默认顺序是“C”(行优先顺序)。
'''
import numpy as np
arr = np.empty((3,2), dtype = int)
print(arr)
numpy. zeros(shape,dtype=float,order="C")
'''
参数说明
参数名称 说明描述
shape 指定数组的形状大小。
dtype 可选项，数组的数据类型
order “C”代表以行顺序存储，“F”则表示以列顺序存储
'''
#返回指定形状大小与数据类型的新数组，并且新数组中每项元素均用 1 填充，语法格式如下：
numpy.ones(shape, dtype = None, order = 'C')
numpy.asarray（sequence，dtype = None ，order = None ）
'''
asarray() 与 array() 类似，但是它比 array() 更为简单。asarray() 能够将一个 Python 序列转化为 ndarray 对象，语法格式如下：
它接受下列参数：
sequence：接受一个 Python 序列，可以是列表或者元组；
dtype：可选参数，数组的数据类型；
order：数组内存布局样式，可以设置为 C 或者 F，默认是 C。
'''
numpy.arrange(start,end,step)
-
-
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 VincentVan！
- 微信
- 支付宝
评论
