Python学习文档

最新推荐文章于 2024-07-04 14:40:34 发布

HxY_*_HxY

最新推荐文章于 2024-07-04 14:40:34 发布

阅读量1k

点赞数 2

分类专栏：随记文章标签： python

本文链接：https://blog.csdn.net/weixin_42545122/article/details/109752346

版权

随记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Python学习文档

一、基本输入与输出
- 1.print()
- 2.input()
- 3.注释
- 4.代码缩进
二、基本数据类型
- 1.数字类型
- - (1).整数
  - (2).浮点数
- 2.字符串类型
- 3.布尔类型
- 4.数据类型转换
三、运算符
- 1.算术运算符
- 2.赋值运算符
- 3.比较运算符
- 4.逻辑运算符
- 5.位运算符
四、序列
- 1.索引
- 2.相关方法
五、列表
- 1.创建和删除
- 2.访问列表元素
- 3.遍历列表
- 4.增改删列表
- 4.1 添加元素
- 4.2 修改元素
- 4.3 删除元素
- 4.4 统计计算
- 4.5 对列表进行排序
- 5. 列表推导式
六、元组
- 1.创建和删除
- 2.访问元组元素
- 3.修改元组元素
- 4.元组推导式
- 5.元组与列表的区别
七、字典
- 1.字典的创建和删除
- 2.访问字典元素
- 3.遍历字典
- 4.增改删字典元素
- 5 字典推导式
八、集合
- 1.集合的创建和删除
- 2.访问集合元素
- 3.集合的添加和删除
- 4.集合的交集、并集和差集运算
- 5. 列表、元组、字典和集合的区别
九、字符串与正则表达式
- 1. 字符串常用操作
- 2. 正则表达式基础
- 3. 正则表达式的使用
十、选择与循环语句
- 1.选择语句
- 2.循环结构语句
十一、函数
- 1. 创建一个函数
- 2. 参数传递
- 3. 返回值
- 4.匿名函数
十二、类和对象
- 1. 定义类
- 2. 创建类的成员并访问
- 3. 属性
- 4. 继承
其他函数
常用python终端命令
总结

根据书上的代码记录的一些东西

一、基本输入与输出

1.print()

a.一条print()语句输出后会自动换行，如果想一次输出多个内容，而且不换行，可以将要输出的内容使用英文半角的逗号分隔（输出不同类型的时候也是用“,”分隔，不要用“+”）。

print(a,b,"要么出众，要么出局")

b.print语句可以输出到文件。

fp = open(r'D:\mr.txt','a+')
print("要么出众，要么出局",file=fp)
fp.close

说明：r:表示后面的字符串完全写入文件，不会解析转义字符等

2.input()

input()可以接收键盘的输入

3.注释

a.单行注释：#
b.多行注释：’’’…’’’，"""…"""
c.中文编码注释：#coding = utf-8 (在文件的第一行加上)

4.代码缩进

采用代码缩进和冒号“:”区分代码的层次，一般是采用一个[Tab]键或4个空格键作为一个缩进量

二、基本数据类型

1.数字类型

(1).整数

十进制整数
八进制整数（0~7组成，0o/0O开头）
十六进制整数（0-9、A-F组成，0x/0X开头）
二进制整数（0-1组成，0b/0B开头）

(2).浮点数

例如：1.414、0.5、-1.732、2.7e2、6.16e-2（科学计数法）等

2.字符串类型

a.’…’：字符串在同一行
b."…"：字符串在同一行
c.’’’…’’’：字符串可以在不同行，且保留格式
d."""…"""：字符串可以在不同行，且保留格式

3.布尔类型

只有以下几种情况得到的值为假，其余情况为真
▲False或None。
▲数值中的零，包括0、0.0、虚数0。
▲空序列，包括字符串、空元组、空列表、空字典。
▲自定义对象的实例，该对象的_bool_方法返回的False，或_len_方法返回的0。

4.数据类型转换

方法	作用
int(x)	将x转换成整数类型
float(x)	将x转换成浮点型类型
complex(real[,imag])	创建一个复数
str(x)	将x转换为字符串
eval(x)	计算在字符串中有效的Python表达式，并返回一个对象
chr(x)	将x转换为一个字符
ord(x)	将一个字符x转换为它对应的整数值
hex(x)	将一个整数x转换为一个十六进制字符串
oct(x)	将一个整数x转换为一个八进制字符串

三、运算符

1.算术运算符

运算符	实例
+	加
-	减
*	乘
/	除
%	求余，即返回除法的余数
//	取整除，即返回商的整数部分
**	幂，即返回x的y次方

2.赋值运算符

运算符	实例
=	简单的赋值
+=	加赋值
-=	减赋值
*=	乘赋值
/=	除赋值
%=	取余数赋值
//=	取整除赋值
**=	幂赋值

3.比较运算符

省略

4.逻辑运算符

逻辑与（and）
逻辑或（or）
逻辑非（not）

5.位运算符

运算符	含义	具体
&	位于	二进制数对应位都是1，结果位才为1，否则为0
丨	位或	二进制数对应位都是0，结果位才为0，否则为1
^	位异或	二进制数对应位相同时（同时为0或同时为1），结果位才为0，否则为1
~	位取反	二进制数1修改为0，0修改为1
<<	左移位	二进制数向左移动指定的位数，溢出丢弃，空位用0补全（左移位运算相当于乘以2的n次幂）
>>	右移位	二进制数向右移动指定的位数，溢出丢弃，空位正数用0补全，负数用1补全（右移位运算相当于除以2的n次幂）

四、序列

1.索引

索引从前往后由0开始，从后往前由-1开始

2.相关方法

函数/操作	参数说明	作用
sname[start : end : step]	sname：序列的名称 start：开始位置 end：截至位置 step：步长，默认为1	获取序列的一部分
name1 + name2	name1：序列的名称 name2：序列的名称	相同类型的序列相加
name * num	name：序列的名称 num：数字	将name的内容重复num次
value in sequence	value ：要检查的值 sequence：序列	检查value是否是sequence的成员
len(sname)	sname：序列的名称	计算序列的长度
max(sname)	sname：序列的名称	计算序列的最大元素
list()		将序列转换为列表
str()		将序列转换为字符串
sum()		计算元素和
sorted()		对元素进行排序
reversed()		反向序列中的元素
enumerate()		将序列组合为一个索引列表，多用在for循环

五、列表

它是python中内置的可变序列。在形式上所有元素都放在一对中括号“[]”中，两个相邻元素使用逗号“,”分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中。

1.创建和删除

赋值运算符直接创建列表
listname = [element 1,element 2,……,element n]
创建空列表
emptylist = []
创建数值列表
list(data)
data表示可以转换为列表的数据
例如，list(range(10,20,2)) 得到 [10,12,14,16,18]
删除列表
del listname

2.访问列表元素

直接用索引即可访问

3.遍历列表

直接用for循环实现
```
for item in listname:
	print(item)
```
使用for循环和enumerate()函数实现
```
for index,item in enumerate(listname):
	print(index,item)
```
index：保存元素的索引
item：用于保存获取到的元素值

4.增改删列表

4.1 添加元素

listname.append(obj)
增加元素，效率高
listname.insert(index,obj)
在index的位置插入元素，效率不如append()高
listname.extend(seq)
将要列表seq的全部元素追加到listname的后面

4.2 修改元素

listname[index] = "修改的内容"

4.3 删除元素

del listname[index]
listname.remove("元素值")

4.4 统计计算

获取指定元素出现的次数
```
listname.count(obj)
```
获取指定元素首次出现的下标
```
lisyname.index(obj)
```
统计数值列表的元素和
```
sum(iterable[,start])
```
iterable：表示要统计的列表
start：列表最后相加的结果加上start的值

4.5 对列表进行排序

使用sort()排序
```
listname.sort(key=None , reverse=False)
```
key：表示指定一个从每个列表元素中提取一个用于比较的键
reverse：为True表示降序排列，False表示为升序排序
sort()方法会改变列表的元素排列顺序
内置的sorted()函数实现
```
newlistname = sorted(iterable , key=None , reverse=False)
```
返回值：会返回一个排序好的列表副本
不会改变原列表的元素排列顺序

5. 列表推导式

生成指定范围的数值列表

list = [Expression for var in range]

#例如
import random
randomnumber = [random.randint(10,100) for i in range(10)]
print("生成的随机数为：",randomnumber)
#生成的随机数为：[38,12,28,26,58,67,100,41,97,15]

Expression ：表达式
var：循环变量
range：采用range()函数生成的range对象

根据列表生成指定需求的列表
```
newlist = [Expression for var in list]

#例如
sale = [int(x*0.5) for x in price]
```
Expression：表达式
var：变量
list：用于生成新列表的原列表
从列表中选择符合条件的元素组成新的列表
```
newlist = [Expression for var in list if condition]

#例如
sale = [x for x in price if x>5000]
```
Expression：表达式
var：变量
list：用于生成新列表的原列表
condition：条件表达式，用于指定筛选条件

六、元组

也是由一系列特定顺序排列的元素组成，但是它是不可变序列。元组又称为不可变的列表。在形式上所有元素都放在一对小括号“()”中，两个相邻元素使用逗号“,”分隔。在内容上，可以将整数、实数、字符串、列表、元组等任何类型的内容放入到列表中。

1.创建和删除

赋值运算符直接创建列表

tuplename = (element 1,element 2,……,element n)

注意：如果要创建的元组值包括一个元素，则需要在定义元组时，在元素的后面加一个“,”

tuplename = ("世界杯冠军",)     #type = "tuple"
tuplename = ("世界杯冠军")      #type = "str"

创建空列表
```
emptytuple = ()
```
创建数值列表
```
tuple(data)   
```
data表示可以转换为列表的数据
例如，tuple(range(10,20,2)) 得到 (10,12,14,16,18)
删除列表
```
del tuplename 
```

2.访问元组元素

直接用索引即可访问

3.修改元组元素

不能不元组的单个元素值进行修改，只能对整个元组重新赋值
元组可以进行连接操作，连接的内容必须都是元组。如果要连接的元组只有一个元素时，一定不要忘记后面的逗号。

4.元组推导式

与列表推导式类似，只是将列表推导式中的中括号“[]”修改为小括号“()”

生成指定范围的数值列表

list = (Expression for var in range)

#例如
import random
randomnumber = (random.randint(10,100) for i in range(10))
print("生成的元组为：",randomnumber)
#生成的元组为：<generator object <genexpr> at 0x0000000003056620>

#又如
import random
randomnumber = (random.randint(10,100) for i in range(10))
randomnumber = tuple(randomnumber)
print("转换后：",randomnumber)
#转换后：(38,12,28,26,58,67,100,41,97,15)

▲ 使用元组推导式生成的结果并不是一个元组或者列表，而是一个生成器对象，需要使用该生成器对象可以将其转换为元组或者列表。
▲ 要使用元组推导器生成的生成器对象，可以直接通过for循环遍历或者直接通过_next()_/next()方法进行遍历

#例如
number = (i for i in range(3))
print(number._next()_)
print(number._next()_)
print(number._next()_)
number = tuple(number)
print("转换后：",number)
#结果
#0
#1
#2
#转换后：()

#又如
number = (i for i in range(3))
for i in number:
	print(i,end = '')
print(tuple(number))
#结果
#0 1 2 3 ()

▲ 无论通过哪种方法进行遍历，如果再想使用该生成器对象，都必须重新创建一个生成器对象，因为遍历后原生成器对象已经不存在了。

根据元组生成指定需求的元组

newtuple = (Expression for var in tuple)

#例如
sale = (int(x*0.5) for x in price)

从元组中选择符合条件的元素组成新的元组

newtuple = [Expression for var in tupleif condition]

#例如
sale = [x for x in price if x>5000]

5.元组与列表的区别

列表	元组
可变序列，元素可以随时更改或者删除	不可变序列，其中的元素不可以修改，除非整体替换
可以使用append()、extend()、insert()、remove()、pop()等方法实现添加和修改列表元素	没有这样的方法，不能向元组添加和修改元素，同样不能删除元素，但是有连接的概念
可以使用切片进行访问和修改列表中的元素	元组也支持切片，但是只能通过切片访问元素，不支持修改
访问和处理速度慢	访问和处理速度快，如果只需要对其中的元素进行访问，而不进行任何修改，建议使用元组
列表不能作为字典的键	元组可以作为字典的键

七、字典

无序的可变序列，保存的内容是以“键值对”的形式存放的。
　　说明：
　　　·通过键而不是索引来读取
　　　·字典是任意对象的无序集合
　　　·字典是可变的，并且可以任意嵌套
　　　·字典中的键必须唯一
　　　·字典中的键不可变

1.字典的创建和删除

赋值运算符直接创建字典
dictionary = {'key1' : 'value1' , 'key2' : 'value2' , ... , 'keyn' : 'valuen}
创建空列表
dictionary = {}
dictionary = dict()
通过映射函数创建字典
dictionary = dict( zip(list1 , list2) )
参数说明：
dictionary：表示字典名称
zip()函数：用于将多个列表或元组对应位置的元素组合成元组，并返回包含这些内容的zip对象。
```
name = ['邓肯','吉诺比利','帕克']
sign = ['石佛','妖刀','跑车']
dictionary = dict(zip(name,sign))
print(dictionary)
#结果
#{'邓肯': '石佛', '吉诺比利': '妖刀', '帕克': '跑车'}
```
通过给定的“关键字参数”创建字典
dictionary = dict(key1 = value1 , key2 = value2 ,..., keyn = valuen)
通过dict对象的fromkeys()创建键为列表，值为空的字典
dictionary = dict.formkeys(lists)
删除字典
del dictionary
dictionary.clear() 清空字典
dictionary.pop() 删除并返回指定“键”的元素
dictionary.popitem() 删除并返回字典中的一个元素

2.访问字典元素

直接用键访问
dictionary['key']
使用字典对象的get()方法
dictionary.get(key,[defult])
说明：key为指定的键；defult为可选项，用于指定当指定的键不存在时，返回一个默认值

3.遍历字典

使用以下方法配合for循环”
dictionary.items() 返回字典的键值对
dictionary.values() 返回字典的值列表
dictionary.keys() 返回字典的键列表

dictionary = {'qq':'84978981', '明日科技':'84978982' , '无语':'0431-84978982'}
for item in dictionary.items():
	print(item)
	
#结果
#('qq', '84978981')
#('明日科技', '84978982')
#('无语', '0431-84978982')

for key,value in dictionary.items():
	print(key ,'  ',value)
	
#结果
#qq    84978981
#明日科技    84978982
#无语    0431-84978982

for item in dictionary.values():
	print(item)
	
#结果
#84978981
#84978982
#0431-84978982

for item in dictionary.keys():
	print(item)

#结果
#qq  
#明日科技
#无语

4.增改删字典元素

dictionary[key] = value
不存在key时，是进行插入操作；存在key时，修改相应key的值。
del dictionary[key]

5 字典推导式

与列表推导式类似

八、集合

集合用于保存不重复元素的，有可变集合（set）和不可变集合（frozenset）两种。仅记录set集合。

1.集合的创建和删除

赋值运算符直接创建集合
setname = {element 1 , element 2 , element 3 , ... , element n}
使用set函数创建
setname = set(iteration)
说明：
iteration：表示要转换为集合的可迭代对象，可以使列表、元组、range对象等。也可以是字符串，如果是字符串，则返回的集合将是包含全部不重复字符的集合

注意：在创建空集合时，只能使用set()函数实现，而不能使用“{}”实现，因为在python中，直接使用一对大括号表示创建一个空字典。

2.访问集合元素

全部输出
遍历访问

3.集合的添加和删除

setname.add(element)
setname.remove(element) 移除指定元素
setname.pop() 从第一个元素开始移除
setname.clear() 清空集合

4.集合的交集、并集和差集运算

“&”交集运算、 “|”并集运算、 “-”差集运算

pf = set(['邓肯','加内特','马龙'])
print('大前锋位置的球员有：' , pf ,'\n')
cf = set(['邓肯'],'奥尼尔','姚明')
print('中锋位置的球员有：' , cf ,'\n')
print('交集运算：' , pf&cf ,'\n') #即是大前又是中锋
print('并集运算：' , pf|cf ,'\n') #大前锋和中锋的全部球员
print('差集运算：' , pf-cf ,'\n') #是大前锋但不是中锋

'''
结果:
大前锋位置的球员有： {'邓肯', '马龙', '加内特'}
中锋位置的球员有： {'姚明', '邓肯', '奥尼尔'}
交集运算： {'邓肯'}
并集运算： {'马龙', '奥尼尔', '姚明', '邓肯', '加内特'}
差集运算： {'马龙', '加内特'}
'''

5. 列表、元组、字典和集合的区别

数据结构	是否可变	是否重复	是否有序	定义符合
列表	可变	可重复	有序	[]
元组	不可变	可重复	有序	()
字典	可变	可重复	无序	{key:value}
集合	可变	不可重复	无序	{}

九、字符串与正则表达式

1. 字符串常用操作

拼接字符串 “+”
字符串之间通过“+”进行拼接，不是字符串通过str()转化为字符串后拼接
计算字符串的长度
前置知识：数字、英文、小数点、下划线和空格各占一个字节；汉字根据编码的不同所占字节数不同，GBK/GB2312编码中占2个字节，在UTF-8/Unicode中一般占3个字节。
```
len(string)
```
len()计算字符串的长度时，不区分英文、数字和汉字，所有字符都认为是一个字符。

计算字符串所占的字节数，如下所示代码：
```
str1 = '人生苦短，我用python!'
length1 = len(str1.encode())  #计算UTF-8编码的字符串的长度
print(length1) 				 #28
length2 = len(str1.encode('gbk'))  #计算GBK编码的字符串的长度
print(length2) 				 #21
```

截取字符串
▷ 采用切片方法实现

string[start : end : step]

#例如
str1 = "人生苦短，我用python!"
substr1 = str1[1]  		#截取第二个字符串
substr2 = str1[5:]		#从第六个字符开始截取
substr3 = str1[:5]		#从左边开始截取5个字符
substr4 = str1[2:5]		#截取第3个到第5个字符
print(substr1 + '/n' + substr2 + '/n' + substr3 + '/n' + substr4)
#结果
#生
#我用python!
#人生苦短,
#苦短,

分隔字符串
```
str.split(sep, maxsplit)
```
str：表示要进行分隔的字符串
sep：用于指定分隔符，可以包含多个字符，默认为None（即所有空字符，包括空格、换行“\n”、制表符“\t”等）
maxsplit：可选参数，用于指定分隔的次数，如果不指定或者为-1，则分隔次数没有限制，否则返回结果列表的元素个数为maxsplit + 1
返回值：分隔后的字符串列表

说明：如果不指定sep参数，那么也不能指定maxsplit参数
检索字符串

▷ count()
```
str.count(sub[, start[, end]])
```
参数解释：
　 str：原字符串
　 sub：要检索的子字符串
　 start：可选参数，表示检索范围的起始位置的索引，如果不指定，则从头开始检索
　 end：可选参数，表示检索范围的终止位置的索引，如果不指定，则检索到结尾
作用：
　　检索指定字符串的另一个字符串出现的次数，如果不存在，则返回0，否则返回出现的次数
　　
▷ find()
```
str.find(sub[, start[, end]])
```
作用：
　　检索是否包含指定的字符串。如果不存在，则返回-1，否则返回首次出现该字符串时的索引
rfind() :与find()方法类似，只是从右边开始查找

▷ index()
```
str.index(sub[, start[, end]])
```
作用：
　　检索是否包含指定的字符串。如果不存在，则会抛出异常，否则返回首次出现该字符串时的索引
rindex() :与index()方法类似，只是从右边开始查找

▷ startwith()
```
str.startwith(sub[, start[, end]])
```
作用：
　　检索是否以指定子字符串开头。如果是则返回True，否则返回False。

▷ endwith()
```
str.endwith(sub[, start[, end]])
```
作用：
　　检索是否以指定子字符串结尾。如果是则返回True，否则返回False。
字母的大小写转换
　▷ lower()
　　将字符串中的大写字母转换为小写字母
　▷ upper()
　　将字符串中的小写字母转换为大写字母
去除字符串中的空格和特殊字符
　▷ strip([chars])
　　去除字符串左右两边的空格和特殊字符或者指定的chars
　▷ lstrip([chars])
　　去除字符串左边的空格和特殊字符或者指定的chars
　▷ rstrip([chars])
　　去除字符串右边的空格和特殊字符或者指定的chars
格式化字符串
　　格式化字符串是指先指定一个模板，在这个模板中预留几个空位，然后再根据需要填上相应的内容。这些空位需要通过指定的符号标记（也称占位符），而这些符号还不会显示出来。
　　
▷ 使用字符串对象的format()方法

str.format(args)
其中str用于指定字符串的显示样式（即模板）；args用于指定要转换的项，如果有多项，则用逗号分隔。
在创建模板时，需要使用“{}”和“:”指定占位符，基本语法格式如下：

{[index] [: [fill] align] [sign] [#] [width] [.precision] [type]]}

index：可选参数，用于指定要设置的格式的对象在参数列表中的索引位置，索引值从0开始
fill：可选参数，用于指定空白处要填充的字符
align：可选参数，用于指定对齐方式（值为“<”表示内容左对齐；值为“>”表示内容右对齐；值为“=”表示内容右对齐，将符号放在填充内容的最左侧，且只对数字类型有效；值为“^”表示内容居中），需要配合width一起使用
sign：可选参数，用于指定有无符号数（值为“+”表示正数加正号，负数加负号；值为“-”表示正数不变，负数加负号；值为空格表示正数加空格，负数加负号）
#：可选参数，对于二进制、八进制和十六进制数，如果加上#，表示会显示“0b/0o/0x”前缀，否则不显示前缀
width：可选参数，用于指定所占宽度
.precision：可选参数，用于指定保留的小数点数
type：可选参数，用于指定类型，其值如下表所示

格式字符	说明	格式字符	说明
s	对字符串类型格式化	b	将十进制整数自动转换成二进制表示再格式化
d	十进制整数	o	将十进制整数自动转换成八进制表示再格式化
c	将十进制整数自动转换成对应的Unicode字符	x或X	将十进制整数自动转换成十六进制表示再格式化
e或E	转换成科学计数法表示再格式化	f或F	转换为浮点数（默认小数点后保留6位）再格式化
g或G	自动在e和f或者E和F中切换	%	显示百分比（默认小数点后保留6位）

#定义模板
template = '编号：{:0>9s} \t公司名称：{:s} \t官网： http://www.{:s}.com'
context1 =  template.format('7' , '百度' , 'baidu')
context2 =  template.format('8' , '明日学院' , 'mingrisoft')
print(context1)
print(context2)

#结果
#编号：000000007 	公司名称：百度 	官网： http://www.baidu.com
#编号：000000008 	公司名称：明日学院 	官网： http://www.mingrisoft.com

2. 正则表达式基础

行定位符
用来描述子串的边界。
“^”表示行的开始
“$”表示行的结尾
元字符

常用元字符

代码	说明
.	匹配出换行符以外的任意字符
\w	匹配字母、数字、下划线或汉字
\W	匹配除字母、数字、下划线或汉字以外的字符
\s	匹配单个的空白符（包括 Tab键和换行符）
\S	除单个的空白符（包括 Tab键和换行符）以外的所有字符
\d	匹配数字
\b	匹配单词的开始或结束，单词的分界符通常是空格、标点符号或者换行
^	匹配字符串的开始
$	匹配字符串的结束

限字符

常用限字符

代码	说明	举例
？	匹配前面的字符零次或多次	colou?r，该表达式可以匹配 colour和color
+	匹配前面的字符一次或多次	go+gle，该表达式可以匹配的范围从gogle到goo···gle
*	匹配前面的字符零次或多次	go*gle，该表达式可以匹配的范围从ggle到goo···gle
{n}	匹配前面的字符n次	go{2}gle，该表达式匹配google
{n,}	匹配前面的字符最少n次	go{2,}gle，该表达式匹配的范围从google到goo···gle
{n,m}	匹配前面的字符最少n次，最多m次	employe{0,2}，该表达式可以匹配employ、employe和employee三种情况

字符类
在方括号中列出要匹配的字符
[aeiou] 　　匹配a、e、i、o、u
[\u4e00-\u9fa5]　　匹配任意汉字
排除字符
在方括号中加入“^”
[ ^a-zA-Z]　　匹配一个不是字母的字符
选择字符、转义字符、分组
“|”、“\”、“()”

3. 正则表达式的使用

在python中使用正则表达式时，是将其作为模式字符串使用的。通常使用原生字符串，即在模式字符串前面加r或R。

使用re模块实现正则表达式操作
import re

匹配字符串

re.match(pattern , string , [flags])
参数说明：
pattern：表示模式字符串，由要匹配的正则表达式转换而来
string：表示要匹配的字符串
flags：可选参数，表示标志位，用于控制匹配方式。常用标志见下表。
返回值：
match()方法返回一个Match对象，且具有几个方法。
Match.start()　匹配值的开始位置
Match.end()　匹配值的结束位置
Match.span()　匹配值的元组
Match.string　要匹配的字符串
Match.group()　匹配到的数据
作用：
从字符串的开始位置开始匹配，当第一个字母不符合条件时，则不再进行匹配，直接返回None。

标志	说明
A或ASCII	对于\w、\W、\b、\B、\d、\D、\s和\S只进行ASCII匹配
I或IGNORECASE	执行不区分字母大写的匹配
M或MULTILINE	将^和$用于包括整个字符串的开始和结尾的每一行
S和DOTALL	使用（.）匹配所有字符，包括换行符
X和VERBOSE	忽略模式字符串中未转义的空格和注释

re.search(pattern , string , [flags])
参数说明：
pattern：表示模式字符串，由要匹配的正则表达式转换而来
string：表示要匹配的字符串
flags：可选参数，表示标志位，用于控制匹配方式。常用标志见下表。
作用：
从字符串的开始位置开始匹配，不符合就跳到下一个字符，直到找到匹配的字符串，或者没找到，返回找到的第一个匹配的字符串后结束。不仅仅可以在字符串的起始位置搜索，其他位置有符合的匹配也可以。
re.findall(pattern , string , [flags])
参数说明：
pattern：表示模式字符串，由要匹配的正则表达式转换而来
string：表示要匹配的字符串
flags：可选参数，表示标志位，用于控制匹配方式
作用：
用于整个字符串中搜索所有符合正则表达式的字符串，并以列表的形式返回。如果匹配成功，则返回包含匹配结构的列表，否则返回空列表。如果在指定的模式字符串中，包含分组，则返回以分组匹配的文本列表。
```
import re
pattern1 = r'[1-9]{1,3}(\.[0-9]{1,3}){3}'    #模式字符串
str1 = '127.0.0.1  192.168.1.66'
match = re.findall(pattern1,str1)
print(match)    
#结果  ['.1', '.66']
#根据(\.[0-9]{1,3})分组得到的结果

pattern2 = r'([1-9]{1,3}(\.[0-9]{1,3}){3})'    #模式字符串
match = re.findall(pattern2,str1)
print(match)    
#结果  [('127.0.0.1', '.1'), ('192.168.1.66', '.66')]
#根据([1-9]{1,3}(\.[0-9]{1,3}){3})分组得到的结果
```

替换字符串

re.sub(pattern , repl , string [, count , flags])
参数说明：
pattern：表示模式字符串，由要匹配的正则表达式转换而来
repl ：表示替换的字符串
string：表示要被查找替换的原始字符串
count：可选参数，表示模式匹配后替换的最大次数，默认值为0，表示替换所有的匹配
flags：可选参数，表示标志位，用于控制匹配方式
作用：
用户实现字符串替换

分隔字符串

re.split(pattern , string [, maxsplit , flags])
参数说明：
pattern：表示模式字符串，由要匹配的正则表达式转换而来
string：表示要匹配的字符串
count：可选参数，表示最大的拆分次数
flags：可选参数，表示标志位，用于控制匹配方式
作用：
用于实现根据正则表达式分隔字符串，并以列表的形式返回，其作用与字符串对象的split()方法类似，所不同的就是分隔字符由模式字符串指定

十、选择与循环语句

1.选择语句

```
if 表达式:
	语句块
```

if 表达式:
	语句块1
else:
	语句块2

if 表达式1:
	语句块1
elif 表达式2:
	语句块2
elif 表达式3:
	语句块3
……
else:
	语句块n

and		同时满足条件
or		满足其中一个条件
not		非

2.循环结构语句

```
for 迭代变量 in 对象:
	循环体
```
```
while 条件表达式:
	循环体
```

break：完全终止循环
continue：直接跳到下一次循环

十一、函数

1. 创建一个函数

def functionname([parameterlist]):
	[''' commnets''']
	[functionbody]
	
参数说明：
	functionname：函数名称
	parameterlist：可选参数，用于指定向函数中传递的参数
	''' commnets'''：可选参数，表示为函数的指定注释
	functionbody：可选参数，用于指定函数体，如果函数什么都不做，可以使用pass语句作为占位符

2. 参数传递

形式参数与实际参数

形式参数：在定义函数时，函数名后面括号中的参数为“形式参数”，也称形参。
实际参数：在调用函数时输入的参数为“实际参数”，也称实参。
当实参为不可变对象时，进行的时值传递；当实参为可变对象时，进行的是引用传递。
值传递和引用传递的基本区别：进行值传递后，改变形参的值，实参的值不变；而进行引用传递后，改变形参的值，实参的值也一同改变。

位置参数

位置参数也称必备参数。调用时的数量和位置必须和定义时是一样的。

关键字参数

指使用形参的名字确定输入的参数值。
functionname( height = 1.83 , weight = 60 , person = "路人甲")

为参数设置默认值

def functionname(..., [parameter1 = defaultvalue1])
	[functionbody]

参数说明：
	parameter1 = defaultvalue1：可选参数，用于指定函数中传递的参数，并且为该参数设置
默认值为defaultvalue1

在定义函数时，指定默认的形参必须在所有参数的最后。

可变参数

可变参数也成为不可变参数，即传入函数中的实际参数可以是0个、一个、两个到任意个。
定义可变参数时，主要有两种形式：一种是*parameter，另一种是**parameter。

*parameter
这种形式表示接收任意多个实际参数并将其放到一个元组中。

def printplayer(*name):
	print('\n我喜欢的NBA球员有：')
	for item in name:
		print(item)
printplayer('邓肯')
printplayer('邓肯','乔丹','帕克')

'''
结果
我喜欢的NBA球员有：
邓肯

我喜欢的NBA球员有：
邓肯
乔丹
帕克
'''

**parameter

这种形式表示接收多个显式赋值的实际参数，并将其放到一个字典中。

def printsign(**sign):
	print()
	for key , value in sign.items():
		print('[' + key + '] 的绰号是： ' + value )

printsign(邓肯 = '石佛' , 罗宾逊 = '海军上校')
printsign(吉诺比利 = '妖刀' , 帕克 = '跑车' , 鲍文 = '鲍三叔')

'''
[邓肯] 的绰号是： 石佛
[罗宾逊] 的绰号是： 海军上校

[吉诺比利] 的绰号是： 妖刀
[帕克] 的绰号是： 跑车
[鲍文] 的绰号是： 鲍三叔
'''

3. 返回值

result = return [value]
参数说明：
	resulu：用于保存返回结果，如果返回一个值，那么result中保存的就是返回值中的一个值，该值可以
		任意类型。如果返回多个值，那么result中保存的是一个元组。
	value：可选参数，用于指定要返回的值，可以返回一个值，也可返回多个值。
	
注意：当函数中没有return语句时，或者省略了return语句的参数时，并返回None，即返回空值。

4.匿名函数

result = lambda [arg1 [,arg2,...argn]] : expression
参数说明：
	result：用于调用lambda表达式。
	[arg1 [,arg2,...argn]]：可选参数，用于指定要传递的参数列表，多个参数间使用逗号“,”分隔。
	expression：必选参数，用于指定要传递的参数列表。

import math
r = 10 
result = lambda r : math.pi*r*r
print('半径为',r,'的圆的面积为：',result(r))

'''
结果：
	u半径为 10 的圆的面积为： 314.1592653589793
'''

十二、类和对象

1. 定义类

class ClassName:
	'''类的帮助信息'''
	def __init__(self):
		...

classname = ClassName()

* 类通常会自动创建__init__()方法。__init__()方法必须包含一个self参数，并且必须是第一个参数。
* self是一个指向实例本身的引用。

2. 创建类的成员并访问

创建实例方法并访问：

def functionName(self, parameterlist):
	block

'''
参数说明：
	self：必要参数，表示类的实例
	parameterlist：用于指定除self参数以外的参数，各参数间使用逗号进行分割
'''

创建数据成员并访问：

类属性：是指定义在类中，并且在函数体外的属性。类属性可以使用类名称或者实例名访问。
实例属性：是指定义在类的方法中的属性，之作用在当前实例中。实例属性只能使用实例名访问。

访问限制
可以在属性和方法名前面添加单下划线、双下划线或首尾加双下划线，从而限制访问权限。

＿＿foo＿＿：首尾加双下划线表示特殊方法，一般是系统自定义名字。
＿foo：以单下划线开头的表示protected（保护）类型的成员，只允许类本身和子类进行访问
＿＿foo：双下划线表示private（私有）类型的成员，只允许定义该方法的类本身进行访问，而也不能通过创建类的实例访问，但是可以通过“类的实例名.＿类名＿＿xxx”的方式访问

3. 属性

创建用于计算的属性
可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性，将方法转换为属性后，可以直接通过方法名来访问方法，而不需要添加一对小括号()。
```
class Rect:
	def __init__(self , width , height):
		self.width = width
		self.heigh = height
	@property
	def area(self):
		return self.width*self.height
rect = Rect(800,600)
print('面积为：',rect.area)
```

为属性添加安全保护机制
使用@property实现只读属性

class TVshow:
	def __init__(self,show):
		self.__show = show
	@property
	def show(self):
		return self.__show
tvshow = TVshow('正在播放《战狼2》')
print('默认：',tvshow.show)
#结果： 默认： 正在播放《战狼2》

4. 继承

class ClassName(baseclasslist):
	'''类的帮助信息'''
	statement

'''
参数说明：
	baseclasslist：用于指定要继承的基类，可以有多个
'''

其他函数

type()
作用：返回变量类型
id()
作用：返回变量所指的内存空间
range(start , end , step)：
参数：
start：指定计数的起始值
end：指定计数的结束值。当range()函数中只有一个参数时，即表示指定计数的结束值
start：指定步长
作用：用于生成一系列连续的整数

该处使用的url网络请求的数据。

常用python终端命令

生成项目的requirements.txt文件：pip freeze > requirements.txt
执行requirements.txt文件：pip install -r requirements.txt

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

HxY_*_HxY

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
Python学习文档

Python学习文档目录一、基本输入与输出1.print()2.input()3.注释4.代码缩进二、基本数据类型1.数字类型(1).整数(2).浮点数2.字符串类型3.布尔类型4.数据类型转换三、运算符1.算术运算符2.赋值运算符3.比较运算符4.逻辑运算符5.位运算符四、序列1.索引2.相关方法其他函数总结目录提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。一、基本输入与输出1.
复制链接

扫一扫

专栏目录