基础

数据类型

字符串，数字，布尔，列表，元组，集合，字典

不可变数据3个：Number,String,bool

可变数据3个: List,Dictionary,Set

高级数据类型：bytes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 数字
x = 1
print(x)
# 字符串
s = "zou"
print(s)
# 布尔
b = True
print(b)
# 列表
list =[1,2,"zou","wen"]
print(list)
# y元组
tuple = (2,4,6,"zou")
print(tuple)
# 字典
dic = {"name":"zou",'age':22}
print(dic)
# 集合
s = {1,'zou',2}
print(s)

列表[]

获取，修改，删除，（数组形式）插入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list = [1,2,3]
# 读取
print(list[0])
# 修改
list[0]=11 #1
print(list) #[11, 2, 3]
# 删除
del list[2]
print(list) #[11, 2]
# 插入
list.append("zou")
print(list) #[11, 2, 'zou']
# 长度
print(len(list)) #3

列表函数

序号 函数
1 len(list) 列表元素个数
2 max(list) 返回列表元素最大值
3 min(list) 返回列表元素最小值
4 list(seq) 将元组转换为列表

列表方法

1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 [list.pop(index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中元素
9 list.sort( key=None, reverse=False) 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表

元组()

元组数据只能读取，不可以修改

字典

键值对形式key，value

读取和修改和设置：数组形式

集合{}

集合里面的值唯一

if条件

1
2
3
4
5
6
n = 8
m = 4
if n>m:
    print("dog")
else:
    print("cat")

循环

while循环

1
2
3
4
5
6
7
n = 1
m = 100
count = 0
while n<=m: #求1-100的和
    count+=n
    n+=1
print(count) #5050

for循环

1
2
3
4
5
6
7
8
9
10
list = [1,2,3,55,66,77]
for i in list:
    print(i)
# 结果    
# 1
# 2
# 3
# 55
# 66
# 77

range函数

遍历数字序列时候可以用range函数

1
2
for i in range(2,25):
    print(i)

九九乘法表

1
2
3
4
5
6
7
8
9
10
11
12
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{j} * {i} = {i*j}", end="\t")
        j += 1
    print()
    i += 1
for i in range(1,10):
    for j in range(1,i+1):
        print(f'{j}*{i}={i*j}',end='\t')
    print()

推导式

列表推导式

1
2
3
# 列表推导式:打印0-40内的偶数
list = [i for i in range(41) if i%2 == 0]
print(list)

字典推导式

1
2
3
dic = { "name":"zou","age":22,"sex":"男"}
dic1 = {k:"11" for k in dic }
print(dic1) #{'name': '11', 'age': '11', 'sex': '11'}

函数

1
2
3
4
def add (num1,num2):
    print(f"求和结果:{num1+num2}")

add(1,4) #求和结果:5

lambda函数

1
2
x = lambda a ,b:a+b
print(x(2,7)) #9

模块

文件输入与读取

1
2
3
4
5
6
7
8
9
10
# 文件输入
# f = open("demo.txt","w",encoding='utf-8')
# f.write("我要开始输入东西了哦"+'\n')
# f.write("你好")
# f.close()

# 文件读取
f = open("demo.txt","r",encoding='utf-8')
r = f.read()
print(r)
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

异常

处理异常：try except

抛出一个异常 : raise

1
2
3
4
5
6
7
8
9
10
11
12
# 捕获异常
try:
  i = 0
  x = 9 / i
  print(x)
except:
  print("出现了异常，我捕捉到了") #出现了异常，我捕捉到了
  
# 抛出异常  
# x = 10
# if x>5:
#     raise Exception("出现了异常，x不能大于5")

类

类的作用是创建对象

1
2
3
4
5
6
7
8
9
10
11
12
13
class my:
    name=''
    age =0
    def __init__(self,n,a):
        self.name=n
        self.age = a
    def save(self):
        return f"姓名：{self.name},年龄{self.age}"
x = my('wen',4)
print(x.name)
print(x.age)
y = x.save()
print(y)

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

1
2
3
4
5
6
7
8
#!/usr/bin/python3
 
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

类的基础

子类（派生类）父类（基类）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class people:
    name="people"
    def save(self):
        print("我是父类的方法")
class student(people):
    name = "student"
    def __init__(self,n):
        people.__init__(self)#这个可以继承父类的属性
        self.name = n
    def save(self):
        print("我是子类的方法")
x= student("hahaah")
print(x.name)
x.save()
#类的基础总结，派生类如果有，就从派生类上面获取，如果没有就从基类上面获取，前提是people.__init__(self)，方法也一样，

命名空间与作用域

内置命名

python内置的名称：abs，char，exception

全局命名

每一个模块的变量，也就是每一个.py文件的变量

局部命名

函数里面的变量

命名空间的查找顺序

局部==》全局==》内置

作用域

全局作用域和局部作用域

标准库

os模块：系统相关，文件夹和文件相关

sys模块：python解释器相关

time模块：处理时间的函数

datetime模块：高级日期和时间处理

random模块：生成随机数的模块

math模块：数学函数模块

re模块：正则表达式的模块

json模块：Json格式的模块

urllib模块：网页和url的模块

当前文件目录：os.getcwd()

当前时间： datetime.date.today()

1
2
3
4
5
6
7
8
9
10
11
import datetime
import os
import random

print(os.getcwd())
current = datetime.date.today() #2023-10-24
current1 = datetime.date.today().strftime("%Y-%m-%d %H:%M:%S") #2023-10-24 00:00:00
current2 = current = datetime.datetime.now() #2023-10-24 17:46:09.132623
print(current)
print(current1)
print(current2)

pip

pip 是 Python 包管理工具，该工具提供了对 Python 包的查找、下载、安装、卸载的功能。

查看版本

1
pip --version

安装包

1
pip install numpy

移出包

1
pip uninstall numpy

查看安装的软件包

1
pip list

request

1
2
3
4
5
6
7
8
# 导入 requests 包
import requests

# 发送请求
x = requests.get('https://www.runoob.com/')

# 返回网页内容
print(x.text)
1
2
3
4
5
6
7
8
9
10
import requests
x = requests.get('https://www.baidu.com/',)
y = x.text

print(x.status_code)
print(x.headers)
print(x.content)
print(x.url)
# print(x.json())
print(x.encoding)

正则表达式

字符类

[0-9] 匹配任意数字，类似与[0,1,2,3,4,5,6,7,8,9]
[a-z] 匹配任何小写字母
[A-Z] 匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[aeiou] [aeiou]
[^aeiou] 除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符
[Pp]ython 匹配 “Python” 或 “python”

特殊字符类

. 匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用象 ‘[.\n]’ 的模式。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。
\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。
[^aeiou] 除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符

re模块符号

^ 以什么开头
$ 以什么结尾
+ 至少一个
？ 0个或一个
{n} 表示n个
{n,m} 表示n-m个

re模常用方法

1.e.match()

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
函数语法：
re.match(pattern, string, flags=0)

函数参数说明：

参数 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格 
1
2
3
4
5
6
7
import re
print(re.match('www','www.baidu.com').span())
print(re.match('baidu','www.baidu.com'))

# 输出：
# (0, 3)
# None

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

函数参数说明：

参数 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格 
1
2
3
4
5
6
7
import re
print(re.search('www','www.baidu.com'))
print(re.search('baidu','www.baidu.com'))

# 输出：
# <_sre.SRE_Match object; span=(0, 3), match='www'>
# <_sre.SRE_Match object; span=(4, 9), match='baidu'>
3.compile()

re.compile 用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，re函数使用。
提前编译可减少多次正则匹配的运行时间
语法格式为：
re.compile(pattern[, flags])

函数参数说明：

参数 描述
pattern 匹配的正则表达式
flags 可选，表示匹配模式
4.re.findall()

re.findall() 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。

函数参数说明：

参数 描述
pattern 正则表达式
string 待匹配的字符串
flags re的一些flag，可不写 
1
2
3
4
5
import re
print(re.findall(pattern='\d+', string='abafa 124ddwa56'))

# 输出：
# ['124', '56']
5.re.sub()

Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)

匹配对象方法 描述
pattern 正则中的模式字符串。
repl 替换的字符串，也可为一个函数。
string 要被查找替换的原始字符串。
count 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags 编译时用的匹配模式，数字形式。 
1
2
3
4
5
6
7
8
import re
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释
num = re.sub(r'#.*$', "", phone)
print("电话号码 : ", num)
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print("电话号码 : ", num)
6.re.split()

re.split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])

函数参数说明：

参数 描述
pattern 匹配的正则表达式
string 要匹配的字符串。
maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见上方可选标志表格

实例：

用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 'a b   c'.split(' ')
['a', 'b', '', '', 'c']
# 发现无法识别连续的空格，用正则表达式试试：

>>> re.split(r'\s+', 'a b   c')
['a', 'b', 'c']
# 无论多少个空格都可以正常分割。加入,试试：

>>> re.split(r'[\s\,]+', 'a,b, c  d')
['a', 'b', 'c', 'd']
# 再加入;试试：

>>> re.split(r'[\s\,\;]+', 'a,b;; c  d')
['a', 'b', 'c', 'd']

贪婪匹配

需要特别指出的是，正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。举例如下，匹配出数字后面的0：

1
2
>>> re.match(r'^(\d+)(0*)$', '102300').groups()
('102300', '')

由于\d+采用贪婪匹配，直接把后面的0全部匹配了，结果0*只能匹配空字符串了。

必须让\d+采用非贪婪匹配（也就是尽可能少匹配），才能把后面的0匹配出来，加个?就可以让\d+采用非贪婪匹配：

1
2
>>> re.match(r'^(\d+?)(0*)$', '102300').groups()
('1023', '00')

正则表达式修饰符

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

re.I 使匹配对大小写不敏感
re.M 多行匹配，影响 ^ 和 $

例子

1.两个特殊的符号’^‘和’$’。他们的作用是分别指出一个字符串的开始和结束

1
2
3
4
"^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）； 
"of despair$"：表示所以以"of despair"结尾的字符串； 
"^abc$"：表示开始和结尾都是"abc"的字符串——只有"abc"自己； 
"notice"：表示任何包含"notice"的字符串。

也可以在方括号里用’^’表示不希望出现的字符，’^’应在方括号里的第一位。
如：”%[^a-zA-Z]%”表示两个百分号中不应该出现字母。

  1. ‘’，’+’和’?’这三个符号，表示一个或一序列字符重复出现的次数。它们分别表示“没有或更多”，“一次或更多”还有“没有或一次”。
1
2
3
4
5
6
7
8
"ab"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；
"ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多；
"ab?"：表示一个字符串有一个a后面跟着零个或者一个b；
"a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。
"ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）；
"ab{2,}"：表示一个字符串有一个a跟着至少2个b；
"ab{3,5}"：表示一个字符串有一个a跟着3到5个b。
请注意，你必须指定范围的下限（如："{0,2}"而不是"{,2}"）。还有，你可能注意到了，''，'+'和'?'相当于"{0,}"，"{1,}"和"{0,1}"。

3.’|’，表示“或”操作：

1
2
3
"hi|hello"：表示一个字符串里有"hi"或者"hello"；
"(b|cd)ef"：表示"bef"或"cdef"；
"(a|b)c"：表示一串"a""b"混合的字符串后面跟一个"c"；

4.’.’可以替代任何字符：

1
2
3
4
5
6
7
8
"a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字； 
"^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）；
方括号表示某些字符允许在一个字符串中的某一特定位置出现：
"[ab]"：表示一个字符串有一个"a"或"b"（相当于"a¦b"）； 
"[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a¦b¦c¦d"或者"[abcd]"）； 
"^[a-zA-Z]"：表示一个以字母开头的字符串； 
"[0-9]%"：表示一个百分号前有一位的数字； 
",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。

5.实例讲解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//校验是否全由数字组成
/^[0-9]{1,20}$/

^ 表示打头的字符要匹配紧跟^后面的规则
$ 表示打头的字符要匹配紧靠$前面的规则
[ ] 中的内容是可选字符集
[0-9] 表示要求字符范围在0-9之间
{1,20}表示数字字符串长度合法为1到20，即为[0-9]中的字符出现次数的范围是1到20次。

/^ 和 $/成对使用应该是表示要求整个字符串完全匹配定义的规则，而不是只匹配字符串中的一个子串。
//校验登录名：只能输入5-20个以字母开头、可带数字、“_”、“.”的字串
/^[a-zA-Z]{1}([a-zA-Z0-9]|[._]){4,19}$/

^[a-zA-Z]{1} 表示第一个字符要求是字母。
([a-zA-Z0-9]|[.*]){4,19} 表示从第二位开始（因为它紧跟在上个表达式后面）的一个长度为4到19位的字符串，它要求是由大小写字母、数字或者特殊字符集[.*]组成。
//校验用户姓名：只能输入1-30个以字母开头的字串
/^[a-zA-Z]{1,30}$/
//校验密码：只能输入6-20个字母、数字、下划线
/^(\w){6,20}$/

\w：用于匹配字母，数字或下划线字符
//校验普通电话、传真号码：可以“+”或数字开头，可含有“-” 和 “ ”

/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/

\d：用于匹配从0到9的数字；
“?”元字符规定其前导对象必须在目标对象中连续出现零次或一次

可以匹配的字符串如：+123 -999 999 ； +123-999 999 ；123 999 999 ；+123 999999等
//校验URL
/^http[s]{0,1}:\/\/.+$/ 或 /^http[s]{0,1}:\/\/.{1,n}$/ (表示url串的长度为length(“<https://>”) + n )

\ / ：表示字符“/”。
. 表示所有字符的集

+ 等同于{1,}，就是1到正无穷吧。
//校验纯中文字符
/^[\u4E00-\u9FA5]+$/

[\u4E00-\u9FA5] ：估计是中文字符集的范围吧