2024-03-05 00:51阅读: 46评论: 0推荐: 0

Python

1. Hello World

 print("Hello World")

使用print输出后自动换行

2. 基础

2.1 语言特点

2.1.1 注释

单行注释

 # 注释一
print("xxx")
 
print("yyy") # 注释二

多行注释

 '''
	@注释一
	@注释二
'''
print("xxx")

注意：三引号在语句中时为字符串定界符

中文注释

主要用于解决 Python 2.x 中不支持直接写入中文的问题

 # -*- coding：编码 -*-
#coding=编码

2.1.2 代码缩进

 height = float(input("输入身高："))
weight = float(input("输入体重："))
bmi = weight/(height*height)
 
if bmi<18.5:
    print("BMI："+str(bmi))
    print("过轻")
if bmi>=18.5 and bmi<24.9:
    print("BMI："+str(bmi))
    print("正常")
if bmi>=24.9 and bmi<29.9:
    print("BMI："+str(bmi))
    print("过重")
if bmi>=29.9:
    print("BMI："+str(bmi))
    print("肥胖")

当缩进数有误时，会报出SyntaxError异常

2.1.3 编码规范

编写规则
- 每个import语句只导入一个模块，尽量避免一次导入多个模块
- 不要在行尾添加分号，也不要用分号将两条命令放在同一行
- 建议每行不超过 80 字符，若超过，则：
  - 大部分情况建议使用小括号将多行内容隐式地连接起来
  - 当超过部分为导入模块的语句或注释里的 URL时，使用反斜杠连接
- 使用必要的空行增加可读性
- 通常，在运算符、函数参数、逗号两侧使用逗号分隔
- 避免在循环中使用+或+=操作符累加字符串
- 适当使用异常处理结构提高程序容错率
命名规范
- 模块名尽量短小，全部小写，使用下划线分隔
- 包名尽量短小，全部小写，不推荐使用下划线分隔
- 类名首字母大写（即 Pascal 风格）
- 模块内部的类采用下划线与 Pascal 风格的类名组成
- 函数、类的属性和方法的命名规则同模块名
- 常量命名时采用全部大写，可以使用下划线
- 使用单下划线开头的模块变量或函数时受保护的，不可用import * from语句导入
- 使用双下划线开头的实例变量或方法是类私有的

2.2 变量

2.2.1 保留字

保留字区分大小写

and	as	assert	async	await	break
class	continue	def	del	elif	else
except	finally	for	from	False	global
if	import	in	is	lambda	nonlocal
not	None	or	pass	raise	return
try	True	while	with	yield

 # 可在 IDLE 中使用以下代码查看 Python 中的保留字
import keyword
keyword.kwlist

2.2.2 标识符

由字母、下划线和数字组成，第一个字符不可以为数字。目前 Python 中只允许使用 ISO-Latin 字符集中的字符 A~Z 和 a~z
不能使用保留字
区分字母大小写
以下单下划线开头的标识符有特殊意义
- 单下划线开头的标识符如_width等表示不能直接访问的类属性，不能通过import *导入
- 双下划线开头的标识符如__add等表示类的私有成员
- 双下划线开头和结尾的是 Python 里专用的表示，如__init__()

2.2.3 定义变量

慎用小写字母l和大写字母O

 # 创建整形变量
number = 1024
 
# 创建字符串变量
nickname = "啊啊啊"

在 Python 中允许多个变量指向同一个值，其内存地址相同

 x=y=1024;
id(x)
id(y)
id(1024)

2.3 基本数据类型

2.3.1 数字

整数
- 二进制整数：101110
- 八进制整数：0o123或0O123（字母 o）
- 十进制整数：-2017
- 十六进制整数：0x1a或0X1a（字母 x）
浮点数

 0.1+0.1
# >>>0.2
0.1+0.2
# >>>0.30000000000000004

复数

使用字母j或J表示复数的虚部

 3.14+12.5j

2.3.2 字符串

 s1 = 'aaa'		# 使用单引号，内容仅限一行
s2 = "bbb"		# 使用双引号，内容仅限一行
s3 = '''ccc
ddd'''			# 使用三引号，内容可以多行
 
print(s1)
print(s2)
print(s3)

2.3.3 布尔类型

以下情况表示为假（False），其余情况为真（True）

False或None
数值为0或0.0或虚数0

2.3.4 数据类型转换

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

2.4 基本输入和输出

2.4.1 输入 input()

 # 字符串输入
tip = input("输入文字：")
# 数值输入
age = int(input("输入年龄："))

当需要 单行输入多个数值 时，可使用以下代码：
split()函数用于区别不同数值的间隔符，不输入为空格
 a, b = map(int, input().split())
c = a+b
print(c)

2.4.2 输出 print()

 a = 2
b = 3
print(4)				# 输出数字
print(a*b)				# 输出计算结果
print(a if a>b else b)	# 输出表达式结果
print("aaa啊啊啊")		  # 输出字符串

Python 支持使用 print 对文件进行直接输入

 fp = open(r'E:\About.txt' , 'a+')
print("python output" , file = fp)
fp.close()

3. 运算符与表达式

3.1 运算符

3.1.1 算术运算符

运算符	说明	实例	结果
+	加	12.45+15	27.45
-	减	4.56-0.26	4.3
*	乘	5*3.6	18.0
/	除	7/2	3.5
%	求余	7%2	1
//	取整除	7//2	3
**	幂	2**3	8

3.1.2 赋值运算符

运算符	说明	举例	展开
=	赋值	`x=y`	`x=y`
+=	加赋值	`x+=y`	`x=x+y`
-=	减赋值	`x-=y`	`x=x-y`
*=	乘赋值	`x*=y`	`x=x*y`
/=	除赋值	`x/=y`	`x=x/y`
%=	求余数赋值	`x%=y`	`x=x%y`
//=	最整除赋值	`x//=y`	`x=x//y`
**=	幂赋值	`x**=y`	`x=x**y`

3.1.3 比较运算符

运算符	作用	举例	结果
>	大于	`'a'>'b'`	False
<	小于	`156<456`	True
==	等于	`'c'=='c'`	True
!=	不等于	`'y'!='t'`	True
>=	大于等于	`479>=426`	True
<=	小于等于	`62.45<=45.5`	False

3.1.4 逻辑运算符

运算符	含义	用法	结合方向
and	逻辑与	`op1 and op2`	左到右
or	逻辑或	`op1 or op2`	左到右
not	逻辑非	`not op`	右到左

3.1.5 位运算符

按位与&
按位或|
按位异或^
按位取反~
左移位运算符<<
右移位运算符>>

3.2 运算符的优先级

3.3 条件表达式

 a = 10
b = 6
if a>b:
    r = a
else:
    r = b
print(r)

上述代码可简写为

 a = 10
b = 6
r = a if a > b else b
print(r)

4. 流程控制语句

4.1 程序结构

4.2 选择语句

4.2.1 if 语句

4.2.2 if...else 语句

4.2.3 if...elif...else 语句

 a = 10
if a<1:
    print(1)
elif a<8:
    print(8)
else:
    print(a)

4.2.4 if 的嵌套

 a = 10
if a>5:
    if a==5:
        print(1)
    else:
        print(2)
else:
    print(3)

4.3 循环语句

4.3.1 while 循环

 i = 1
while(i<10):
    i+=1
print(i)

4.3.2 for 循环

4.3.2.1 数值循环

 print("计算 1+2+3+...+100 的结果为：")
result = 0
for i in range(101):
    result += i
print(result)

range(start,end,step)

start：用于指定计数的起始值，可省略（默认为0）

end：用于指定计数的结束值，不可省略

step：用于指定步长，即两个数的距离

4.3.2.2 字符串遍历

 string = 'abcde'
print(string)
for ch in string:
    print(ch)

4.3.3 循环嵌套

4.4 break、continue、pass 语句

4.4.1 break

 for i in range(10):
    if(i==5):
        print(i)
        break

4.4.2 continue

 for i in range(5):
    if(i==3):
        continue
    print(i)

4.4.3 pass

表示空语句，起到占位符的作用

 for i in range(1,10):
    if i%2==0:
        print(i,end=' ')
    else:
        pass

5. 列表与元组

5.1 序列

5.1.1 索引

 a = ["a","b","cd"]
print(a[-1])	# 输出最后一个元素 cd
print(a[0])		# 输出第一个元素 a
print(a[1])		# 输出第二个元素 b

5.1.2 切片

切片操作是访问序列中元素的另一种方法

语法格式：sname[start:end:step]

sname：序列的名称
start：切片的开始位置（包括）
end：切片的结束位置（不包括）
step：切片的步长

 a = ["a","b","c","d"]
print(a[1:4])		# ['b', 'c', 'd']
print(a[1:4:2])		# ['b', 'd']

5.1.3 序列相加

 a = ["a","b"]
b = ["c","d"]
print(a+b)		# ['a', 'b', 'c', 'd']

5.1.4 乘法

 a = ["a","b"]
print(a*2)		# ['a', 'b', 'a', 'b']

5.1.5 查找存在性

 a = ["a","b","c"]
print("a" in a)			# True
print("a" not in a)		# False

5.1.6 计算序列的长度、最大值、最小值

 a = [1,3,5,0]
print(len(a))	# 4
print(max(a))	# 5
print(min(a))	# 0

5.1.7 其他内置函数

函数	说明
`list()`	序列转换为列表
`str()`	序列转换为字符串
`sum()`	计算元素和
`sorted()`	对元素排序
`reversed()`	对元素逆序
`enumerate()`	将序列组合为一个索引序列，多用在 for 循环中

5.2 列表

5.2.1 创建和删除

5.2.1.1 使用赋值运算符直接创建

 num = [1,2,3]
sss = ['aaa',2,"bbb"]

5.2.1.2 创建空列表

 emptylist = []

5.2.1.3 创建数值列表

 # 创建偶数列表
print(list(range(10,20,2)))

5.2.1.4 删除列表

 list = [1,2]
del list

5.2.2 访问列表元素

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

5.2.3 遍历列表

 a = [1,2]
for i in a:
    print(i)
 
b = [3,4]
for index,item in enumerate(b):
    print(index,item)

5.2.4 添加、修改和删除列表元素

5.2.4.1 添加元素

 # 添加单个元素
a = [4,5]
a.append(6)
print(a)
 
# 将一个列表的全部元素添加到另一个列表
b = ['a','b']
b.extend(a)
print(b)

5.2.4.2 修改元素

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

5.2.4.3 删除元素

根据索引删除

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

根据元素值删除

 a = [1,2,3]
print(a)
a.remove(3)
print(a)

5.2.5 对列表进行统计计算

5.2.5.1 获取指定元素出现的次数

 a = [1,2,3,3]
b = a.count(3)
print(b)

5.2.5.2 获取指定元素首次出现的下标

 a = [1,3,2,3]
b = a.index(3)
print(b)

5.2.5.3 统计数值列表的元素和

 a = [1,3,2,3]
b = sum(a)
print(b)

5.2.6 对列表进行排序

列表对象的sort()函数

 a = [1,3,2,3]
a.sort()
print(a)				# [1, 2, 3, 3]
a.sort(reverse=True)
print(a)				# [3, 3, 2, 1]
 
b = ['An','Co','bn']
b.sort()
print(b)				# ['An', 'Co', 'bn']
b.sort(key=str.lower)	# 忽略大小写
print(b)				# ['An', 'bn', 'Co']

内置的sorted()函数

 a = [1,3,2,3]
a = sorted(a)
print(a)				# [1, 2, 3, 3]
a = sorted(a,reverse=True)
print(a)				# [3, 3, 2, 1]

5.2.7 列表推导式

生成指定范围的数值列表

 # 生成 10 个 10~100 之间的整数
import random
n = [random.randint(10,100) for i in range(10)]
print(n)

根据列表生成指定需求的列表

 a = [10,100,150]
b = [int(x*0.5) for x in a]
print(a)
print(b)

从列表在选择符合条件的元素组成新的列表

 a = [10,100,200]
b = [x for x in a if x<100]
print(a)
print(b)

5.2.8 二维列表

直接定义创建

 list = [[1,2,3],[4,5,6],[7,8,9]]
print(list)

使用 for 循环嵌套创建

 arr = []
for i in range(3):
    arr.append([])		# 在空链表中在添加一个空列表
    for j in range(3):
        arr[i].append(j)
print(arr)

使用列表推导式创建

 arr = [[j for j in range(3)]for i in range(2)]
print(arr)

5.3 元组

与列表的区别在于元组是不可变序列

5.3.1 元组的创建和删除

使用赋值运算符直接创建元组

 t1 = (1,2,3)
t2 = ("a","b","c")
t3 = ('P',23,t1,["d","e"])
t4 = ('a',"b",'''c''')
t5 = ("aaaa")
 
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)

创建空元组

 emptytuple = ()

创建数值元组

 print(tuple(range(10,20,2)))

删除元组

 t = (1,2)
print(t)
del t
print(t)

5.3.2 访问元组元素

 t = (1,2,3,4,5)
print(t)		# (1, 2, 3, 4, 5)
print(t[1])		# 2
print(t[:2])	# (1, 2)
for i in t:
    print(i,end=" ")	# 1 2 3 4 5

5.3.3 修改元素

 t = (1,2,3)
print(t)
# 报错
# t[2] = 4
# print(t)
t = (1,4,3)
print(t)
t = t + (5,6)
print(t)

5.3.4 元组推导式

 import random
t = (random.randint(10,100) for i in range(10))
print(t)

由上述代码结构可以看出，使用元组推导式生成的结果并不是一个元组或列表，而是一个生成器对象

应使用下述代码

 import random
t = (random.randint(10,100) for i in range(10))
t = tuple(t)
print(t)

 t = (i for i in range(3))
print(t.__next__())		# 0
print(t.__next__())		# 1
print(t.__next__())		# 2
t = tuple(t)
print(t)			# ()

6. 字典和集合

6.1 字典

6.1.1 字典的创建和删除

 dic = {'a':'12','b':'34','c':'56'}
print(dic)
emptydictionary1 = {}
emptydictionary2 = dict()

通过映射函数创建字典

 t1 = ('a','b','c')
l1 = ['a','b','c']
l2 = ['1','2','3']
d1 = dict(zip(l1,l2))
print(d1)
d2 = {t1:l2}
print(d2)

通过给定的 “ 键-值对 ” 创建字典

 d1 = dict(aa = '1',bb = '2')
print(d1)		# {'aa': '1', 'bb': '2'}
# 创建一个只包括名字的字典
l1 = ['a','b','c','d']
d2 = dict.fromkeys(l1)
print(d2)		# {'a': None, 'b': None, 'c': None, 'd': None}

6.1.2 访问字典

 dic = {'a':'12','b':'34','c':'56'}
print(dic['a'] if 'a' in dic else 'none')	# 12
print(dic['d'] if 'd' in dic else 'none')	# none

6.1.3 遍历字典

 dic = {'a':'12','b':'34','c':'56'}
for item in dic.items():
    print(item)

6.1.4 添加、修改和删除字典元素

 dic = {'a':'12','b':'34','c':'56'}
print(dic)		# {'a': '12', 'b': '34', 'c': '56'}
# 添加
dic['d'] = '78'
print(dic)		# {'a': '12', 'b': '34', 'c': '56', 'd': '78'}
# 修改
dic['a'] = '01'
print(dic)		# {'a': '01', 'b': '34', 'c': '56', 'd': '78'}
# 删除
del dic['a']
print(dic)		# {'b': '34', 'c': '56', 'd': '78'}

6.1.5 字典推导式

 l1 = ['a','b','c']
l2 = ['1','2','3']
dic = {i:j for i,j in zip(l1,l2)}
print(dic)

6.2 集合

6.2.1 创建集合

直接使用{}创建

 s1 = {1,2,3}
s2 = {'a','b'}
s3 = {'a',12,(2,'t')}

使用set()函数创建

 s1 = set("dcabefg")
s2 = set((1,2,3))
s3 = set([1,2,3])
 
print(s1)
print(s2)
print(s3)

6.2.2 向集合中添加和删除元素

添加

 s = {1,2}
print(s)
s.add(3)
print(s)

删除

 s = {1,2,3,4,5}
print(s)	# {1, 2, 3, 4, 5}
 
s.remove(2)	# 删除指定元素
print(s)	# {1, 3, 4, 5}
 
s.pop()		# 删除第一个元素
print(s)	# {3, 4, 5}
 
s.clear()	# 清空集合
print(s)	# set()

6.2.3 集合的交集、并集和差集运算

 s1 = {1,2,3,4}
s2 = {3,4,5,6}
print("交集: ",s1 & s2)	# 交集:  {3, 4}
print("并集: ",s1 | s2)	# 并集:  {1, 2, 3, 4, 5, 6}
print("差集: ",s1 - s2)	# 差集:  {1, 2}

7. 字符串

7.1 字符串编码转换

7.1.1 使用`encode()`方法编码

str.encode([encoding="utf-8"][,errors="strict"])

str：表示要进行转换的字符串
encoding=""：用于指定进行转码时采用的字符编码
errors=""：用于指定错误的处理方式
- strict：遇到非法字符就抛出异常
- ignore：忽略非法字符
- replace：用?替代非法字符
- xmlcharrefreplace：使用 XML 的字符引用

7.1.2 使用`decode()`方法解码

str.decode([encoding="utf-8"][,errors="strict"])

str：表示要进行转换的二进制数据
encoding=""：用于指定进行转码时采用的字符编码
errors=""：用于指定错误的处理方式

 s = "你好世界"
print(s)	# 你好世界
g = s.encode("GB2312")
print(g)	# b'\xc4\xe3\xba\xc3\xca\xc0\xbd\xe7'
r = g.decode("GB2312")
print(r)	# 你好世界

7.2 字符串常用操作

7.2.1 拼接字符串

 s1 = 'abc'
s2 = '123'
print(s1+s2)
 
# 不同的数据类型使用以下代码进行拼接
num = 999
res = s1 + str(num) + s2 + '\n' + s1
print(res)

7.2.2 计算字符串长度

 s = "12345"
print(len(s))	# 5

7.2.3 截取字符串

 s = 'abcd1234'
s1 = s[1]		# b
s2 = s[3:]		# d1234
s3 = s[:3]		# abc
s4 = s[2:4]		# cd
print(s1+'\n'+s2+'\n'+s3+'\n'+s4+'\n')

7.2.4 分割、合并字符串

分割

 s = '1---23/a/456'
s1 = s.split()		# 采用默认分隔符进行分割
s2 = s.split('a')	# 采用多个字符进行分割
s3 = s.split('/')	# 采用 / 进行分割
s4 = s.split('-',4)	# 采用 - 分割且仅分割前四个
 
print(s1)	# ['1---23/a/456']
print(s2)	# ['1---23/', '/456']
print(s3)	# ['1---23', 'a', '456']
print(s4)	# ['1', '', '-23/a/456']

合并

 s = ['a','b']
t = '@'.join(s)
print(t)		# a@b
print('@'+t)	# @a@b

7.2.5 检索字符串

count()方法

用于检索指定字符串在另一字符串中出现次数

 s = 'aabbaa'
print(s.count('a')) # 4

find()方法

用于检索是否包含指定字符串并返回首次出现的索引（不包含则返回 -1）

 s = 'aabbaa'
print(s.find('b'))	# 2
print(s.find('c'))	# -1

index()方法

与find()方法类似，区别在于字符串不存在时不会返回 -1，而是报错

 s = 'aabbaa'
print(s.index('b'))	# 2
print(s.index('c'))

startswith()方法

用于检索字符串是否以指定字符串开头

 s1 = "@a @b @c"
s2 = "@a *b @c"
s3 = "*a @b @c"
print(s1.startswith('@'))	# True
print(s2.startswith('@'))	# True
print(s3.startswith('@'))	# False

7.2.6 字母的大小写转换

lower()方法
upper()方法

 s = "ABCdef"
print(s.lower())	# abcdef
print(s.upper())	# ABCDEF

7.2.7 去除字符串中的空格和特殊字符

strip()方法

用于去除字符串左右两侧的空格和特殊字符

 s = "://aa/a   "
print("[ "+s+" ]")			# [ ://aa/a    ]
print("[ "+s.strip()+" ]")	 # [ ://aa/a ]

lstrip()方法

用于去除字符串左侧的空格和特殊字符

 s = "   aaa   "
print("[ "+s+" ]")			# [    aaa    ]
print("[ "+s.strip()+" ]")	 # [ aaa    ]

rstrip()方法

用于去除字符串右侧的空格和特殊字符

7.2.8 格式化字符串

使用%操作符

格式字符	说明
`%s`	字符串（采用`str()`显示）
`%r`	字符串（采用`repr()`显示）
`%c`	单个字符
`%o`	八进制整数
`%d`或者`%i`	十进制整数
`%x`	十六进制整数
`%e`	指数（基底写为 e）
`%E`	指数（基底写为 E）
`%f`或者`%F`	浮点数
`%%`	字符 %

 template ='num: %03d name: %s text: --%s--'
s1 = (2,'aaa','x')
s2 = (123,'bbb','y')
print(template%s1)	# num: 002 name: aaa text: --x--
print(template%s2)	# num: 123 name: bbb text: --y--

使用字符串对象的format()方法

格式字符	说明
S	对字符串类型格式化
D	十进制整数
C	将十进制整数转换为对应的 Unicode 字符
e 或者 E	转换为科学计数法表示再格式化
g 或者 G	自动在 e 和 f 或者 E 和 F 之间切换
b	将十进制整数自动转换成二进制表示再格式化
o	将十进制整数自动转换成八进制表示再格式化
x 或者 X	将十进制整数自动转换成十六进制表示再格式化
f 或者 F	转换成浮点数再格式化
%	显示百分比

 template ='num: {:0>3s} name: {:s} text: --{:s}--'
s1 = template.format('2','aaa','x')
s2 = template.format('123','bbb','y')
print(s1)	# num: 002 name: aaa text: --x--
print(s2)	# num: 123 name: bbb text: --y--

8. Python 中使用正则表达式

8.1 正则表达式语法

8.1.1 行定位符

行定位符用于描述字符串的边界，^表示行的开始，$表示行的结束

 ^tm		# 匹配行以 tm 开头的字符串
tm$		# 匹配行以 tm 结尾的字符串
tm		# 匹配行以 tm 开头或结尾的字符串

8.1.2 元字符

常用元字符

代码	说明
`.`	匹配除换行符以外的任意字符
`\w`	匹配字母或数字或下划线或汉字
`\s`	匹配任意的空白符
`\d`	匹配数字
`\b`	匹配单词的开始或结束
`^`	匹配字符串的开始
`	代码
----	----------------------------
`.`	匹配除换行符以外的任意字符
`\w`	匹配字母或数字或下划线或汉字
`\s`	匹配任意的空白符
`\d`	匹配数字
`\b`	匹配单词的开始或结束
`^`	匹配字符串的开始
匹配字符串的结束

8.1.3 重复

常用限定符

限定符	说明	举例
`?`	匹配前面的字符零次或一次	`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

8.1.4 字符类

通过在[]中填写相关项可进行字符匹配

[aeiou]：匹配元音字母
[0-9]：匹配数字
[.?!]：匹配标点符号
[\u4e00-\u9fa5]+：匹配连续多个汉字

8.1.5 排除字符

^字符用于排除功能

[^a-zA-Z]：匹配一个不是字母的字符

8.1.6 选择字符

|字符用于选择功能

(\d|x|X)$：匹配身份证号最后一位

8.1.7 转义字符

\字符用于转义功能

\.

8.1.8 分组

()也可以用于分组

8.1.9 在 Python 中使用正则表达式

例：将匹配以字母 m 开头的单词的正则表达式转换为模式字符串

以下直接使用引号定界符的代码有误
- '\bm\w*\b'
需要将其中的\进行转义
- '\\bm\\w*\\b'
由于模式字符串中可能包括大量的特殊字符和反斜杠，所以需要添加前缀r或R
- r'\bm\w*\b

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

import re

8.2.1 匹配字符串

常用标志

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

match()

 import re
pattern = r'mr_\w+'
string = 'MR_SHOP mr_shop'
match = re.match(pattern,string,re.I)
print('匹配值的起始位置: ',match.start())	# 0
print('匹配值的结束位置: ',match.end())		# 7
print('匹配位置的元组: ',match.span())		# (0, 7)
print('要匹配的字符串: ',match.string)		# MR_SHOP mr_shop
print('匹配的数据: ',match.group())		  # MR_SHOP

search()

 import re
pattern = r'mr_\w+'
string = 'MR_SHOP mr_shop'
match = re.search(pattern,string,re.I)
print(match)	# <re.Match object; span=(0, 7), match='MR_SHOP'>
string = '名称 MR_SHOP mr_shop'
match = re.search(pattern,string,re.I)
print(match)	# <re.Match object; span=(3, 10), match='MR_SHOP'>

findall()

 import re
pattern = r'mr_\w+'
string = 'MR_SHOP mr_shop'
match = re.findall(pattern,string,re.I)
print(match)	# ['MR_SHOP', 'mr_shop']
string = '名称 MR_SHOP mr_shop'
match = re.findall(pattern,string)
print(match)	# ['mr_shop']

8.2.2 替换字符串

 import re
pattern = r'1[34578]\d{9}'
string = '字符串: 13611111111'
result = re.sub(pattern,'1XXXXXXXXXX',string)
print(result)	# 字符串: 1XXXXXXXXXX

8.2.3 使用正则表达式分割字符串

 import re
pattern = r'[?|&]'
url = 'http://www.xxx.com.login.jsp?un="xxx"&pwd="yyy"'
result = re.split(pattern,url)
print(result)	# ['http://www.xxx.com.login.jsp', 'un="xxx"', 'pwd="yyy"']

9. 函数

9.1 函数的船舰和调用

9.1.1 创建函数

 def functionname([parameterlist]):
    ['''comments''']
    [functionbody]

9.1.2 调用函数

 def fun(string):
    import re
    pattern = r'(aa)|(bb)|(cc)'
    sub = re.sub(pattern,'__',string)
    print(sub)
s = 'aawwwawbbccqqcc'
fun(s)

9.2 参数传递

9.2.1 形参和实参

9.2.2 位置参数

数量必须与定义时一致
- 即传入的数据必须为每个参数进行赋值，不可缺失或超越
位置必须与定义时一致
- 即传入的数据必须与每个参数的类型一一匹配

9.2.3 关键字参数

使用形参的名字来确定输入的参数值

9.2.4 为参数设置默认值

 def fun_bmi(person,height,weight):
    print(person+"的身高为"+str(height)+"米，体重为"+str(weight)+"千克")
    bmi = weight/(height*height)
    print(person+"的 BMI 指数为"+str(bmi))
def fun_bmi_(height,weight,person="ccc"):
    print(person+"的身高为"+str(height)+"米，体重为"+str(weight)+"千克")
    bmi = weight/(height*height)
    print(person+"的 BMI 指数为"+str(bmi))
# main
fun_bmi("aaa",1.60,50)	# 9.2.1
fun_bmi(height=1.70,person="bbb",weight=55)	# 9.2.3
fun_bmi_(1.80,60)	# 9.2.4

9.2.5 可变参数

*parameter

 def fun(*name):
    print("name: ")
    for item in name:
        print(item)
fun('aa')
fun('aa','bb','cc')
fun('aa','bb')

**parameter

 def fun(**name):
    for key,value in name.items():
        print("["+key+"]的 name: "+value)
fun(a='aaa',b='bbb')
d = {'a':'aaa','b':'bbb','c':'ccc'}
fun(**d)

9.3 返回值

 def fun(num):
    n1 = num+1
    n2 = num*2
    return n1,n2
x=int(input())	# 4
y=fun(x)
print(y[0])		# 5
print(y[1])		# 8

9.4 变量的作用域

全局变量
局部变量

 x = 1
print(x)		# 1
def fun(x):
    print(x)	# 1
    x = 2
    print(x)	# 2
fun(x)
print(x)		# 1

9.5 匿名函数

 import math
r = 10
'''
	@ 原函数如下
	def area(r):
		result = math.pi*r*r
		return result
	print(area(r))
'''
# 使用 lambda 表达式
result = lambda r:math.pi*r*r
print(result(r))

10. 面向对象程序设计

10.1 面对对象概述

10.1.1 对象

对象表示任意存在的事物，分静态（对象的属性）和动态（对象的行为）两种对象

10.1.2 类

类是封装对象的属性和行为的载体

10.1.3 特点

封装
- 封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对用户隐藏其实现的细节，这就是封装的思想
继承
- 继承是实现重复利用的重要手段，子类通过继承复用了父类的属性和行为的同时，又添加了子类特有的属性和行为
多态
- 将父类对象应用于子类的特征就是多态

10.2 类的定义和使用

10.2.1 定义类

 class ClassName:
    statement

10.2.2 创建类的实例

10.2.3 创建`init()`方法

 class Class:
    def __init__(self):
        print("Output")
c = Class()

10.2.4 创建类的成员并访问

 class Class:
    st1 = "aaa"
    st2 = "bbb"
    st3 = "ccc"
    def __init__(self):
        print("Output")
        print(Class.st1)
        print(Class.st2)
        print(Class.st3)
c1 = Class()
c2 = Class()
c2.st2 = "ddd"
print(c1)
print(c2)
print(c2.st2)

10.2.5 访问限制

单下划线开头的表示 protected（保护）类成员
双下划线开头的表示 private （私有）类成员

 class Class:
    s = "aaa"
    _s = "bbb"
    __s = "ccc"
c = Class()
print(c.s)		# aaa
print(c._s)		# bbb
print(c.__s)	# Error

10.3 属性

10.3.1 创建用于计算的属性

通过@property创建用于计算属性的语法

 class Rect:
    def __init__(self,width,height):
        self.width = width
        self.height = height
    @property
    def area(self):
        return self.width*self.height
rect = Rect(8,6)
print(rect.area)	# 48

10.3.2 为属性添加安全保护机制

 class Show:
    def __init__(self,show):
        self.__show = show
    @property
    def show(self):
        return self.__show	# 返回私有属性的值
sw = Show("xxx")
print(sw.show)		# xxx
sw.show = "yyy"
print(sw.show)		# Error

10.4 继承

10.4.1 继承的基本语法

 class Fruit:
    color = "green"
    def opt(self,color):
        # 输出形式参数
        print(color)
        # 输出类属性
        print(Fruit.color)
class Apple(Fruit):
    color = "red"
    def __init__(self):
        print("apple")
a = Apple()
a.opt(a.color)

10.4.2 方法重写

 class Fruit:
    color = "green"
    def opt(self,color):
        # 输出形式参数
        print(color)
        # 输出类属性
        print(Fruit.color)
class Apple(Fruit):
    color = "red"
    def opt(self,color):	# 重写方法
        print(color)
        print(Fruit.color)
    def __init__(self):
        print("apple")
a = Apple()
a.opt(a.color)

10.4.3 派生类中调用基类的`__init()`方法

 class Fruit:
    def __init__(self,color="green"):
        Fruit.color = color
    def opt(self,color):
        print(color)
        print(Fruit.color)
class Apple(Fruit):
    color = "red"
    def __init__(self):
        print("apple")
        super().__init__()
a = Apple()
a.opt(a.color)

11. 高级

11.1 模块

11.1.1 模块概述

在 Python 中，一个扩展名为.py的文件就称为一个模块

11.1.2 自定义模块

11.1.2.1 创建模块

 def fun_bmi(per,hei,wei):
    print(per+"的身高为"+hei+"米，体重为"+wei+"千克")
    bmi = wei/(hei*hei)
    print(bmi)

11.1.2.2 使用`import`语句导入模块

 import bmi	# 导入11.2.1模块
bmi.fun_bmi("aaa",1.75,120)

11.1.2.3 使用`from...import`语句导入模块

 from bmi import fun_bmi

11.1.2.4 模块搜索目录

 import sys
print(sys.path)

临时添加
增加.pth文件
在PYTHONPATH环境变量中添加

11.1.3 Python 中的包

11.1.3.1 Python 程序的包结构

aaa 项目名

admin 用于保存后台文件的包

home 用于保存前台文件的包

templates 用于保存模板文件的包

x.py 入口程序

11.1.3.2 创建和使用包

创建包

在 IDLE 中，创建一个名称为__init__.py的文件，保存在确定的项目文件夹中，并且在该文件中不写任何内容

使用包

 # 引入 xxx 包中的 yyy 模块
import xxx.yyy

11.2 常见异常

异常	描述
NameError	尝试访问一个没有声明的变量引发的错误
IndexError	索引超出序列范围引发的错误
IndentationError	缩进错误
ValueError	传入的值错误
KeyError	请求一个不存在的字典关键字引发的错误
IOError	输入输出错误
ImportError	当`import`语句无法找到模块或`from`无法在模块中找到相应的名称时引发的错误
AttributeError	尝试访问未知对象属性引发的错误
TypeError	类型不合适引发的错误
MemoryError	内存不足
ZeroDivisionError	除数为 0 引发的错误

11.3 网络爬虫

11.3.1 分类

通用网络爬虫
- 又称全网爬虫（Scalable Web Crawler）。由于爬行范围和数量巨大，获取的数据量巨大，对速度和存储空间要求较高，同时对顺序要求低，刷新时间较长，一般采用并行工作方式
- 主要应用于大型搜索引擎中
- 主要由初始URL集合、URL队列、页面爬行模块、页面分析模块、页面数据库、链接过滤模块等构成
聚焦网络爬虫（Focused Crawler）
- 又称主题网络爬虫（Topical Crawler），是指按照预先定义好的主题，有选择地进行相关网页爬取的爬虫。相对于通用网络爬虫，聚焦网络爬虫不会将目标资源定位在整个互联网中，而是将爬取的目标网页定位在于主题相关的页面中
- 主要应用在对特定信息爬取，为某一类特定人群提供服务
增量式网络爬虫（Incremental Web Crawler）
- 增量式对应增量式更新。增量式更新是指在更新的时候只更新改变的地方，其他地方不更新，所以这种爬虫只会在需要的时候爬行新产生或发生更新的页面，其他则不会爬取。
深层网络爬虫
- 表层网络（Surface Web）：指的是不需要提交表单，使用静态的超链接就可以直接访问的静态页面
- 深层网络（Deep Web）：指的是大部分内容不能通过静态链接获取的、隐藏在搜索表单后面的，需要用户提交一些关键字才能获得的 Web 页面
- 主要通过 6 个基本功能的模块（爬行控制器、解析器、表单分析器、表单处理器、响应分析器、LVS 控制器）和 2 个爬虫内部数据结构（URL 列表、LVS 表）等部分构成（其中 Label Value Set 表示标签 / 数值集合，用来表示填充表单的数据源）

11.3.2 基本原理

获取初始的 URL，该 URL 地址是用户自己制定的初始爬取的网页
爬取对应 URL 地址的网页时，获取新的 URL 地址
将新的 URL 地址放入 URL 队列中
从 URL 队列中读取新的 URL，然后一句新的 URL 爬取网页，同时从新的网页中获取新的 URL 地址，递归
设置停止条件，未设置则直至无法获取新的 URL 地址为止

编辑于 2022/12/9

-End-

上一篇在 Visual Studio 2022 中创建一个类似于旧版本 Visual Studio 中的 Win32 Console Application 项目

下一篇Vue3 + TypeScript 开发指南

本文作者：SRIGT

本文链接：https://www.cnblogs.com/SRIGT/p/18053131

posted @ 2024-03-05 00:51 SRIGT 阅读(46) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

	height = float(input("输入身高："))
	weight = float(input("输入体重："))
	bmi = weight/(height*height)

	if bmi<18.5:
	print("BMI："+str(bmi))
	print("过轻")
	if bmi>=18.5 and bmi<24.9:
	print("BMI："+str(bmi))
	print("正常")
	if bmi>=24.9 and bmi<29.9:
	print("BMI："+str(bmi))
	print("过重")
	if bmi>=29.9:
	print("BMI："+str(bmi))
	print("肥胖")

	# 可在 IDLE 中使用以下代码查看 Python 中的保留字
	import keyword
	keyword.kwlist

	# 创建整形变量
	number = 1024

	# 创建字符串变量
	nickname = "啊啊啊"

	s1 = 'aaa' # 使用单引号，内容仅限一行
	s2 = "bbb" # 使用双引号，内容仅限一行
	s3 = '''ccc
	ddd''' # 使用三引号，内容可以多行

	print(s1)
	print(s2)
	print(s3)

	# 字符串输入
	tip = input("输入文字：")
	# 数值输入
	age = int(input("输入年龄："))

	a = 2
	b = 3
	print(4) # 输出数字
	print(a*b) # 输出计算结果
	print(a if a>b else b) # 输出表达式结果
	print("aaa啊啊啊") # 输出字符串

	fp = open(r'E:\About.txt' , 'a+')
	print("python output" , file = fp)
	fp.close()

	print("计算 1+2+3+...+100 的结果为：")
	result = 0
	for i in range(101):
	result += i
	print(result)

	a = ["a","b","cd"]
	print(a[-1]) # 输出最后一个元素 cd
	print(a[0]) # 输出第一个元素 a
	print(a[1]) # 输出第二个元素 b

	a = ["a","b","c","d"]
	print(a[1:4]) # ['b', 'c', 'd']
	print(a[1:4:2]) # ['b', 'd']

	a = ["a","b","c"]
	print("a" in a) # True
	print("a" not in a) # False

	a = [1,3,5,0]
	print(len(a)) # 4
	print(max(a)) # 5
	print(min(a)) # 0

	a = [1,2]
	for i in a:
	print(i)

	b = [3,4]
	for index,item in enumerate(b):
	print(index,item)

	# 添加单个元素
	a = [4,5]
	a.append(6)
	print(a)

	# 将一个列表的全部元素添加到另一个列表
	b = ['a','b']
	b.extend(a)
	print(b)

	a = [1,3,2,3]
	a.sort()
	print(a) # [1, 2, 3, 3]
	a.sort(reverse=True)
	print(a) # [3, 3, 2, 1]

	b = ['An','Co','bn']
	b.sort()
	print(b) # ['An', 'Co', 'bn']
	b.sort(key=str.lower) # 忽略大小写
	print(b) # ['An', 'bn', 'Co']

	a = [1,3,2,3]
	a = sorted(a)
	print(a) # [1, 2, 3, 3]
	a = sorted(a,reverse=True)
	print(a) # [3, 3, 2, 1]

	# 生成 10 个 10~100 之间的整数
	import random
	n = [random.randint(10,100) for i in range(10)]
	print(n)

	arr = []
	for i in range(3):
	arr.append([]) # 在空链表中在添加一个空列表
	for j in range(3):
	arr[i].append(j)
	print(arr)

	t1 = (1,2,3)
	t2 = ("a","b","c")
	t3 = ('P',23,t1,["d","e"])
	t4 = ('a',"b",'''c''')
	t5 = ("aaaa")

	print(t1)
	print(t2)
	print(t3)
	print(t4)
	print(t5)

	t = (1,2,3,4,5)
	print(t) # (1, 2, 3, 4, 5)
	print(t[1]) # 2
	print(t[:2]) # (1, 2)
	for i in t:
	print(i,end=" ") # 1 2 3 4 5

	t = (1,2,3)
	print(t)
	# 报错
	# t[2] = 4
	# print(t)
	t = (1,4,3)
	print(t)
	t = t + (5,6)
	print(t)

	import random
	t = (random.randint(10,100) for i in range(10))
	print(t)

	import random
	t = (random.randint(10,100) for i in range(10))
	t = tuple(t)
	print(t)

	t = (i for i in range(3))
	print(t.__next__()) # 0
	print(t.__next__()) # 1
	print(t.__next__()) # 2
	t = tuple(t)
	print(t) # ()

	dic = {'a':'12','b':'34','c':'56'}
	print(dic)
	emptydictionary1 = {}
	emptydictionary2 = dict()

	t1 = ('a','b','c')
	l1 = ['a','b','c']
	l2 = ['1','2','3']
	d1 = dict(zip(l1,l2))
	print(d1)
	d2 = {t1:l2}
	print(d2)

	d1 = dict(aa = '1',bb = '2')
	print(d1) # {'aa': '1', 'bb': '2'}
	# 创建一个只包括名字的字典
	l1 = ['a','b','c','d']
	d2 = dict.fromkeys(l1)
	print(d2) # {'a': None, 'b': None, 'c': None, 'd': None}

	dic = {'a':'12','b':'34','c':'56'}
	print(dic['a'] if 'a' in dic else 'none') # 12
	print(dic['d'] if 'd' in dic else 'none') # none

	dic = {'a':'12','b':'34','c':'56'}
	for item in dic.items():
	print(item)

	dic = {'a':'12','b':'34','c':'56'}
	print(dic) # {'a': '12', 'b': '34', 'c': '56'}
	# 添加
	dic['d'] = '78'
	print(dic) # {'a': '12', 'b': '34', 'c': '56', 'd': '78'}
	# 修改
	dic['a'] = '01'
	print(dic) # {'a': '01', 'b': '34', 'c': '56', 'd': '78'}
	# 删除
	del dic['a']
	print(dic) # {'b': '34', 'c': '56', 'd': '78'}