目录
第一天
1.环境配置：Python，Pycharm，Pycharm配置Python
2.学习软件：Typora，文档python.md
1.1、下载安装python-3.8.2-amd64.exe 官网地址：https://www.python.org/downloads/windows/
1.2、 下载地址： PyCharmhttps://www.jetbrains.com/pycharm/download/#section=windows
安装教程 https://www.icode9.com/content-3-705622.html
第二天
1.定义int类型， float类型，complex类型，str类型，None类型，bool类型，bytes类型，tuple类型的变量，并打印其类型， 使用显式定义，例如：1， 2.2
2.定义int类型， float类型，complex类型，str类型，None类型，bool类型，bytes类型，tuple类型的变量，并打印其类型， 使用类型()定义
3.定义一个空元组，定义一个嵌套元组：嵌套元组中的每个元组包含两个元素
a1=1
a2='jj'
a3=1+2j
a4=None
a5=True
a6 = bytes('我爱Python编程',encoding='utf-8')
a7=(1,'NU')
print(a1,type(a1))
print(a2,type(a2))
print(a3,type(a3))
print(a4,type(a4))
print(a5,type(a5))
print(a6,type(a6))
print(a7,type(a7))
a8=(a7,a7)
print(a8,type(a8))
第三天
1.tuple的count和index方法的使用
2.定义list类型变量的两种方式
3.定义一个list,往list添加一个元素4
4.移除list中最后一个元素的两种方式
5.新定义一个list2将list2中的元素加到list中。
将list和list2合并产生一个新列表
6.对list进行排序，排序后倒置
7.整理浅拷贝和深拷贝的区别
8.定义dict的两种方式，访问dict中一个元素的vlaue
count 计数
获取指定字符出现的次数
index 角标索引
获取指定字符第一次出现的位置
index(x,y,z)
获取指定字符x 从y到z区域中第一次出现的位置
a=(1,2,1,1,1)
print(a.count(1))#4
print(a.index(2))#1
print(a.index(1,0,3))#0
a=[1,2,'DD']#定义列表
a.append(4)#添加元素
print(a)
a.pop()#删除元素
print(a)
a.pop(2)#删除角标为2的元素
print(a)
b=[1,2,3,4]
a.extend(b)#将b添加到a中
print(a)
c=a+b;#定义一个新列表为a合并b
print(c)#排序
a.sort()
print(a)
a.sort(reverse=True)#倒序
print(a)
直接使用等于获取的是地址
修改列表时原列表也会发生改变
用copy方法获取的是新的指针方向
但是如果列表内嵌套了列表
修改 嵌套内的列表时 原列表也会发生改变
属于浅copy
a3=[1,2]
a4=[1,a3]
print(a4)#[1, [1, 2]]
a5=a4.copy()
a5[1].append(5)
print(a4)#[1, [1, 2, 5]]
使用 deepcopy()方法可进行深copy
即使修改列表内的列表值原列表也不会发生改变
需要导包（from copy import deepcopy）
from copy import deepcopy
a6 = deepcopy(a4)
a6[1].append(3)
print(a6)#[1, [1, 2, 5, 3]]
print(a4)#[1, [1, 2, 5]]
字典
a1={1:2,
3:4}
print(a1)
print(a1[1])
第四天
1.字典操作
dict_data = {1: 2, 2: 3}
1.使用两种不同方式向字典中分别添加: 4: 5, 5: 6
2.获取字典key=8的元素，不能报错
3.获取字典的items，keys， values
4.弹出字典的最后一个元素
2.集合操作：
1.定义一个空集合
2.给定一个字符串：“lsdljfjaldfaowioueroiuwoe”, 对字符串取重后排序(注意排序后的结果还是字符串)
3.set_data1 = {1, 2, 3, 4}
set_data2 = {2, 3, 5}
求两个集合的交集
求两个集合的并集
求两个集合的差集
3.进制转换：
给定十进制28：
将28转换为二进制
将28转换为八进制
将28转换为十六进制
给定8进制0o12:
将八进制转成二进制
将八进制转成十六进制
4.ascii码转换
将65转换为ascii字符
将z转换成ascii编号
字典操作
dict_data={1:2,2:3}
dict_data[4]=5
dict_data.update([(5,6)])
print(dict_data)#{1: 2, 2: 3, 4: 5, 5: 6}
print(dict_data.get(8))#None
print(dict_data.items())#dict_items([(1, 2), (2, 3), (4, 5), (5, 6)])
print(dict_data.values())#dict_values([2, 3, 5, 6])
print(dict_data.keys())#dict_keys([1, 2, 4, 5])
print(dict_data.popitem())#(5, 6)
集合操作
A=set()
print(A)#set()
S = 'lsdljfjaldfaowioueroiuwoe'
A = set(S)
print(A)#{'d', 'j', 'l', 'w', 'a', 'i', 'e', 'r', 'f', 'o', 'u', 's'}
B = list(A)
print(''.join(A))#djlwaierfous
B.sort(key=S.index)
print(B)#['l', 's', 'd', 'j', 'f', 'a', 'o', 'w', 'i', 'u', 'e', 'r']
print(''.join(B))#lsdjfaowiuer
set_data1 = {1, 2, 3, 4}
set_data2 = {2, 3, 5}
C=set_data1.intersection(set_data2)#{2, 3}
print(C)
C = set_data1.union(set_data2)#{1, 2, 3, 4, 5}
print(C)
C=set_data1.difference(set_data2)#{1, 4}
print(C)
进制转换
n=28
print(bin(n))#0b11100
print(oct(n))#0o34
print(hex(n))#0x1c
M=0O12
print(bin(M))#0b1010
print(hex(M))#0xa
ascii码转换
i=65
print(chr(i))#A
i= 'z'
print(ord(i))#122
第五天
运算符:
1.逻辑运算符的使用：
给出两个条件： 分别使用 and 和 or来连接，输出结果
2.身份运算符的使用：
定义一个变量：如果变量为空，打印此变量为None，不为空打印此变量不为空
3.成员运算符的使用：
定义一个列表：然后给定一个值，如果这个值在列表中，打印列表包含这个值，
如果不在列表中，打印列表不包含这个值
条件控制语句：
给定学生的信息:dict_data = {“张三”: 21, “李四”: 20, “王五”: 19, “赵六”：18,
“刘七”: 19, “张麻子”: 20, “耿耿”: 20, “余淮”: 19}
21级需要学习C语言
20级需要学习Python
19级需要学习Java
18级需要学习Go
请统计出学习C语言，学习Python，学习Java，学习Go的人数
for循环：
1.定义一个字典：
打印出字典里面的每一个key
打印出字典里面的每一个value
打印出字典里的每一对key和value
2.定义一个元组，请打印出元组的下标和下标对应的元素的值
print(True and False)#False
print(True or False)#True
i=None
if(i==None):
print("为空")
else:
print(i)
#为空
L=[1,2,3,4]
if 1 in L:
print("1在列表里")
else:
print("1不在列表里")
#1在列表里
dict_data = {"张三": 21,
"李四": 20,
"王五": 19,
"赵六": 18,
"刘七": 19,
"张麻子":20,
"耿耿": 20,
"余淮": 19}
A,B,C,D=0,0,0,0
for i in dict_data:
if dict_data[i]==18:
A=A+1
elif dict_data[i]==19:
B=B+1
elif dict_data[i]==20:
C=C+1
else:
D=D+1
print("需要学习c的学生有",D,"个")
print("需要学习python的学生有",C,"个")
print("需要学习java的学生有",B,"个")
print("需要学习go的学生有",A,"个")
'''
需要学习c的学生有 1 个
需要学习python的学生有 3 个
需要学习java的学生有 3 个
需要学习go的学生有 1 个
'''
dict_data1 = {"张三": 21,
"李四": 20,
"王五": 19,
"赵六": 18,
"刘七": 19,
"张麻子":20,
"耿耿": 20,
"余淮": 19}
for i in dict_data1:
print(i)
'''
张三
李四
王五
赵六
刘七
张麻子
耿耿
余淮
'''
for i in dict_data1:
print(dict_data1[i])
''' 21
20
19
18
19
20
20
19
''''
for i in dict_data1:
print(i,dict_data1[i])
""" 张三 21
李四 20
王五 19
赵六 18
刘七 19
张麻子 20
耿耿 20
余淮 19
"""
i=(1,2,3,4,5)
for k,j in enumerate(i):
print(k,j)
'''
0 1
1 2
2 3
3 4
4 5
'''
第六天
1.打印 9 * 9 乘法表: 使用while循环和for循环
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 …
…
9 * 1 = 9 9 * 2 = 18 … 9 * 9 = 81
选做: 使用while单层循环完成
i=0
while i<9 :##用两层循环嵌套
i+=1
j=0
while j < i:
j+=1
print(i,'*',j,'=','%2s'% (i*j),end=' ')##加end 使末尾不换行 %2s 使保持输出格式
print()## 隔段换行
单个while
i=1
j=0
while i<10 :
if j<i:
j+=1
print(i, '*', j, '=', '%2s' % (i * j), end=' ')
if i==j:
i+=1
j=0
print()
第七天
1.异常处理的使用：
- 列表超出索引: list_data = [1, 2, 3] => list_data[3]
- 定义一个元组: tuple_data = (1, 2, 3) => tuple_data[2] = 10
- 定义一个字典：dict_data = {1: 2, 2: 3} => dict_data[3]
2.文件操作：
新建一个文件: python0922.txt => Today I learned Exception and Open File.
复制当前这个文件Python0922.txt,粘贴到当前路径下：且新的文件名：python0924.txt
异常处理
list_data = [1, 2, 3]
try:
print(list_data[3])
except IndexError:
print("列表超出索引:")
list_data1 = (1, 2, 3)
try:
list_data1[1]=3
except TypeError:
print("元组不可改变:")
list_data2 ={
1:2,
3:4
}
try:
list_data2[5]
except KeyError:
print("字典key值不存在:")
###文件创建
a=open("python0922.txt",'r',encoding="UTF-8")#打开文件
copy=a.read()#获取内容
with open('python0924.txt','w')as f1:#创建文件并起别名
f1.write(copy)#导入内容
f1.close()#关闭
a.close()#关闭
第八天
1.写文本文件：
一次写入多行内容
关闭文件
重新打开，往文件追加新的一行内容
2.读文件：
读取前三十字符所在的行
3.什么是模块
模块导入的几种方式
4.什么是包，然后包和文件夹的区别
如何指定 from package import * 导入的模块
第一步 创建file.txe文件 并写入多行信息
f1=open("file.txt","w")
f1.writelines(["222210\n","222210222210222210222210\n","222210222210222210222210222210222210222210222210\n","222221022221022221022210\n"])
f1.close()
f1=open("file.txt","a+")
f1.write("这是追加的内容")
f1.close()
第二步 读文件
f1=open("file.txt","r+")
F1=f1.readlines(30)
print(F1)
第三步 模块导入方法
import xxx
#这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。
#需要使用模块名称来访问函数：
xxx.abc()
import python2
python2.abc()
from XXX import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：
from XXX import abc()
from python2 import abc
abc()
from … import * 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
可以将非下划线开头的语句获取到
from python2 import *
abc()
第四
包是一个特殊的文件夹，它能将你的数据及时更新备份
而文件夹不能
python包是：
包是一个有层次的文件目录结构，它定义了由n个模块或n个子包组成的python应用程序执行环境。
通俗一点：包是一个包含__init__.py 文件的目录，该目录下一定得有这个__init__.py文件和其它模块或子包。
文件夹可以是路径途径 存放各种文件、包 等
第九天
1.输入：
请输入一个0和1组成的二进制的字符串: 1101
把它转换成10进制
输出: 13
s = input("请输入一个由1和0组成二进制字符串: “)
d = 1
while s:
d = 2
s = s[1:]
print(f"转换成十进制的数为: {3}”)
2. 四种格式化输出方法：
姓名 年龄 家庭住址
四行记录，每行记录使用一种格式化方式(当前这种格式化方法中涉及的都展示出来
除了%，其他的都需要有:宽度，对齐方式，填充)
3. str剩余方法：
replace(self, old, new, count=-1, /)
join(self, iterable, /)
isdigit
isalpha
isalnum
strip
split
splitlines
第一题
s = input("请输入一个由1和0组成二进制字符串: ")
d = 0
while s:
d = d*2 + int(s[0])
s = s[1:]
print(f"转换成十进制的数为: {d}")
四种格式化输出
date = ["张三", 20, "西安的"]
print("姓名：%4s,年龄：%-5d,家庭地址:%10s"%(date[0],date[1],date[2]))
print(f"姓名：{date[0]:<10},年龄：{date[1]:^5},家庭地址:{date[2]:>10}")
print("姓名：{1},年龄：{2},家庭地址:{0}".format(date[0],date[1],date[2]))
print("姓名：",date[0].center(10,"*"),"年龄：",date[1],"家庭地址:",date[2].rjust(10,"*"))
file = open("file.txt", "a", encoding="utf-8")
print(("姓名：",date[0],",年龄",date[1],",家庭地址:",date[2]),file=file )
结果
姓名： 张三,年龄：20 ,家庭地址: 西安的
姓名：张三 ,年龄： 20 ,家庭地址: 西安的
姓名：20,年龄：西安的,家庭地址:张三
姓名： ****张三**** 年龄： 20 家庭地址: *******西安的
还有一个输出到文件里了 // 姓名： 张三 ,年龄 20 ,家庭地址: 西安的
注 额好像超了4种 建议取前4个 如果有其他的答案 请私信或评论 谢谢
字符串
replace(self, old, new, count=-1, /)
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
str="zzsaixuexi"
print(str.replace('z','a',1))#azsaixuexi
join(self, iterable, /)
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
srg=["ZZS","AI","XUEXI"]
str = "-";
print(str.join(srg))
isdigit
如果字符串只包含数字则返回 True 否则返回 False。
str="zzsaixuexi"
print(str.isdigit())#False
isalpha
如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
str="zzsaixuexi"
print(str.isalpha())#True
isalnum
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
str="zzsaixuexi"
print(str.isalnum())#True
strip
返回移除字符串头尾指定的字符生成的新字符串。
str = "00000003210ZZSAXX01230000000";
print(str.strip('0')) # 去除首尾字符 0
#3210ZZSAXX0123
str2 = " ZZSAIXX " # 去除首尾空格
print(str2.strip())
#ZZSAIXX
split
参数
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。
返回值
返回分割后的字符串列表。
str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str)
print(str.split( )) # 以空格为分隔符，包含 \n
print(str.split(' ', 1 ))# 以空格为分隔符，分隔成两个
結果
Line1-abcdef
Line2-abc
Line4-abcd
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
splitlines
参数
keepends – 在输出结果里是否保留换行符(’\r’, ‘\r\n’, \n’)，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值
返回一个包含各行作为元素的列表。
print(str2.strip())
str1 = 'ab c\nde fg\nkl'
print(str1)
print(str1.splitlines())
print(str1.splitlines(True))
结果
ab c
de fg
kl
['ab c', 'de fg', 'kl']
['ab c\n', 'de fg\n', 'kl']
第十天
1.切片使用
s = “123456789”
a. 使用切片倒序输出
b. 使用切片取出偶数的数字
c. 使用切片取出奇数的数字
d. 取出后5位字符
2.函数：
- 定义一个函数，且有一个参数
函数功能：取得传入字符串的第一个字符和最后一个字符
并返回 - 定义一个函数：可以接收一个参数或多个位置参数，参数的个数不定
传入多个参数：包含整型，浮点型，
功能：计算所有参数的和， 然后返回 - 定义一个函数：可以接收一个或多个关键字参数，参数的个数不定
传入多个参数
功能：输出所有关键字参数的key和value - 定义一个参数，2个位置参数，2个关键字参数
功能：打印所有参数
a.全部以关键字参数的形式传参
b.全部以位置参数的形式传参
c.以位置参数和关键字混合的形式传参
d.带默认值的参数不传，只传位置参数
切片使用
s = “123456789”
a. 使用切片倒序输出
b. 使用切片取出偶数的数字
c. 使用切片取出奇数的数字
d. 取出后5位字符
s = "123456789"
print(s[::-1])#987654321
print(s[::2])#13579
print(s[1::2])#2468
print(s[-5:])#56789
函数
- 定义一个函数，且有一个参数
函数功能：取得传入字符串的第一个字符和最后一个字符
并返回
def Sw(X):
return X[0],X[-1]
s = "123456789"
print(Sw(s))#('1', '9')
- 定义一个函数：可以接收一个参数或多个位置参数，参数的个数不定
传入多个参数：包含整型，浮点型，
功能：计算所有参数的和， 然后返回
def Qh(*X):
he=0
while X :
he=he+X[0]
X=X[1:]
return he
print(Qh(1,1.1,35,2.5))#39.6
- 定义一个函数：可以接收一个或多个关键字参数，参数的个数不定
传入多个参数
功能：输出所有关键字参数的key和value
def kv(**X):
return X.keys(),X.values()
print(kv(name="X",HEHE=1))
#(dict_keys(['name', 'HEHE']), dict_values(['X', 1]))
- 定义一个参数，2个位置参数，2个关键字参数
功能：打印所有参数
a.全部以关键字参数的形式传参
b.全部以位置参数的形式传参
c.以位置参数和关键字混合的形式传参
d.带默认值的参数不传，只传位置参数
def hunhe(X1,Y1,X=None,Y=None):
return X1,Y1,X,Y
print(hunhe(X1=1,Y1=2,X=3,Y=2))
print(hunhe(1,2,3,4))
print(hunhe(1,2,3,Y=4))
print(hunhe(1,2))
结果
(1, 2, 3, 2)
(1, 2, 3, 4)
(1, 2, 3, 4)
(1, 2, None, None)
第十一天
1.定义一个函数：总共有四个参数：
前两个参数，只能以位置参数传入
后两个参数，只能以关键字参数传入
def defs(A,B,/,*,C,D):
return
2.定义一个嵌套函数，
外层函数打印this is outing function
内层函数功能:打印This is inner function
def nesting():
print("this is outing function")
def inside():
print("This is inner function")
return inside()
nesting()
结果
this is outing function
This is inner function
https://blog.csdn.net/weixin_44851971/article/details/106216497
参考文章
3.定义一个递归函数：打印斐波那契数列
F[n]=F[n-1]+Fn-2
def Fibonacci(i):#获取斐波那契
if i==1:
return 1
if i==2:
return 1
return Fibonacci(i-1)+Fibonacci(i-2)
def FibonacciBl(i):#打印斐波那契
for n in range(1,i+1):
print(Fibonacci(n),end=" )
FibonacciBl(5)#1 1 2 3 5
4.随机数
随机一个1-10之间的小数
随机一个99-999之间的整数
从列表出随机一个元素
从列表中随机两个元素
import random
print(random.uniform(1,10))#1到10之间小数
print(random.randint(99,999))#99到999之间整数
list = [1,2,3,4,5,6,7]
print(random.sample(list, 1))
print(random.sample(list, 2))
5.打印当前时间且格式为: 2021/10/06 10:00:00,星期x,第x天,AM,第x周
import time
print(time.strftime('%Y-%m-%d %U %w %H:%M:%S', time.localtime()))
- 递归访问目录： 且目录中嵌套目录，有层次的列出给定目录中所有的文件和文件夹
切换目录: os.chdir(path)
列出当前目录中所有的文件和文件夹 os.listdir(path), path: 绝对路径
判断是否是文件: os.path.isfile(path)
判断是否是目录: os.path.isdir(path)
拼接路径： os.path.join(path1, path2, path3…)
第十二天
1.定义一个类(不限定定义哪个类)：
要求: a.需要有一个类变量
b.需要有>=2个的对象变量
c.定义一个方法：打印类变量和对象变量
d.使用print打印对象->输出为This is a object
e.实例化两个对象：且两个对象相加等于2
f.为对象添加一个临时变量temp_var
class cas:
bl = 0
def __init__(self,name,age):
self.name=name
self.age=age
def prin(self):
print(self.bl,self.age ,self.name)
def this():
return "This is a object"
a=cas
print(a.this())
b=cas(name=1,age=5)
print(b.name+b.age)
a.NL=3
print(a.NL)
有问题需要修改
2.定义一个父类：
要求：包含三个对象变量，且其中一个对象变量使用_命名
定义一个方法：命名使用__命名
定义一个子类继承上边的父类：且定义一个和父类方法名相同的方法(__)
实例化子类的对象
访问带_的对象变量
访问父类中的__xxx方法
访问子类中的__xxx方法
3.super的使用:
定义一个类A, 里面又一个方法print_info
定义一个类B, 里边有一个方法print_info和一个方法say_something
定义一个类C, 里边有一个方法say_something
定义一个类D, 里边有一个方法print_info和一个方法say_something
定义一个类E,继承类A, 类B, 类C，类D
实例化类E的对象
执行print_info和say_something方法
利用super，让执行print_info时调用B中print_info
利用super, 让执行say_something时调用C中say_something
利用super, 让执行print_info和say_something时调用
D中print_info和say_something
4.什么是闭包?
闭包的特征?
定义闭包，完成的功能为:传入一个数求和并输出
例如: 传入10 ->输出10
传入15 ->输出25
传入20 ->输出45
第十三天
1.定义一个装饰器：打印函数运行花费的时间
你在执行之前获取一个时间
执行函数
在执行函数之后获取一个时间
去求时间差
time模块
def decorate(text):
def innter(*args,**kwargs):
import time
n=time.time()
i=10000
while i>0://时间太短不好计算
i-=1
text(*args,**kwargs)
print(time.time()-n)
return innter
@decorate
def fund(i):
print(f"东西{i}")
fund(1)
第十四天
1.定义一个类：
要求：包含一个对象属性，且用_(单下划线)命名的
定义一个类方法(装饰器)
定义一个静态方法(装饰器)
定义委托属性(三个类装饰器): 可以访问_命名的属性的值
可以修改_命名的属性的值
可以删除_命名的属性
执行：
实例一个对象
调用类方法(类和对象两种方式)
调用静态方法(类和对象两种方式)
对象.委托属性
对象.委托属性 = value
del 对象.委托属性
2. 定义一个生成器函数，生成1-10
使用next(generator)方法获取1-10
使用for循环获取
第十五天作业
1.# 自己定义一个MyIterator, 实现range的功能
range(start, stop, step) => MyIterator
range(10) # start=0, stop=10, step=1
rang(10) # range(start=0, stop, step=1) =>start=10
range(0,10)
range(0,10,2)
MyIterator(10)
MyIterator(0,10)
MyIterator(0,10,2)
- re中函数的使用(自己写用例来使用)：
match
fullmatch
search
findall
finditer
split
sub
subn
complie
MyIterator类代码
class MyIterayor:
def __init__(self,start=None,stop=None,step=None):
if stop==None:
self.stop=start
self.start=0
else:
self.start =start
self.stop=stop
if step==None:
self.step=1
else:
self.step = step
def __iter__(self):
return self
# def __next__(self):
# if self.step>0:
# if self.start < self.stop:
# self.start = self.start + self.step
# return self.start - self.step
# else:
# raise StopIteration
# else:
# if self.start > self.stop:
# self.start = self.start + self.step
# return self.start - self.step
# else:
# raise StopIteration
def __next__(self):#改进版
n=True
if self.step < 0:
n = False
if (self.start < self.stop)==n:
self.start = self.start + self.step
return self.start - self.step
else:
raise StopIteration
for i in MyIterayor(10):
print(i,end="")
print()
for i in MyIterayor(0, 10):
print(i, end="")
print()
for i in MyIterayor(0, 10,2):
print(i, end="")
print()
for i in MyIterayor(10,1,-1):
print(i,end="")
结果
0123456789
0123456789
02468
10987654321
第十六天
1.匹配你的手机号:
第一位只能是1
第二位不能是: 1, 2
手机的位数是11位:
怎么去验证你写的正则表达式呢：
不是1开始的，
第二不能是1,2,
长度不能为9位或者10位，或者12位
2.匹配QQ号:
第一位不能为0
qq号长度5-10位
第十七天
1.匹配身份证号的正则表达式
2.URL地址
3.匹配年月日日期 格式2018-12-6
4.8位强密码
5.分组的应用
有需要更新的或者错误的地方 请私信我修改 更新
因本文章会持续更新 强烈建议收藏一波
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
