1.正则作业
import re
from functools import reduce
1.1 写一个正则表达式判断一个字符串是否是IPv4地址
规则：一个ip地址由4个数字组成，每个数字之间用.连接。每个数字的大小是0-255
255.189.10.37 正确
256.189.89.9 错误
匹配 0-255 的正则: \d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]
0~9: \d
10~99: [1-9]\d
100~199: 1\d\d
200~249: 2[0-4]\d
250~255: 25[0-5]
re_str = r'((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
ip = '255.189.10.37'
print(re.fullmatch(re_str, ip))
1.2 计算一个字符串中所有的数字的和
例如：字符串是：‘hello90abc 78sjh12.5’ 结果是90+78+12.5 = 180.5
写一个可以匹配所有数字的正则表达式
re_str = r'\d+\.\d+|\d+'
str1 = 'hello90abc 78sjh12.5'
result = re.findall(re_str, str1)
print(reduce(lambda x, y: float(x) + float(y), result))
1.3 验证输入的内容只能是汉字
re_str = r'[\u4e00-\u9fa5]+'
1.4 电话号码验证
from re import fullmatch
rule=r'1[3-9]\d{9}'
result=fullmatch(rule,'13299990909')
print(result) # <re.Match object; span=(0, 11), match='13299990909'>
1.5 验证输入用户名和QQ号是否有效并给出对应的提示信息
要求：
用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
QQ号是5~12的数字且首位不能为0
username = input('请输入用户名:')
qq = input('请输入qq号:')
if re.fullmatch(r'[a-zA-Z\d_]{6,20}', username):
print('用户名有效')
else:
print('用户名无效')
if re.fullmatch(r'[1-9]\d{4,11}', qq):
print('qq号有效')
else:
print('qq号无效')
1.6 拆分长字符串：将一首诗的中的每一句话分别取出来(re的sqlit函数)
poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
str1 = 'and123hu123aaa456klk98ll7hu123oop'
\# print(str1.split('123'))
result = re.split(r'\d+', str1)
print(result)
result = re.split(r'[，。]', poem)
print(result)
print(re.fullmatch(r'c:\\rapidminer\\lib\\plugs', r'c:\rapidminer\lib\plugs'))
正则表达式最前面加(?i)表示匹配的时候忽略大小写
re_str = r'(?i)abc'
print(re.fullmatch(re_str, 'Abc'))
单行(?s)和多行(?m)匹配：单行匹配的时候.可以匹配\n，多行匹配的时候.不能匹配\n
re_str = r'(?s)abc.123'
print(re.fullmatch(re_str, 'abc\n123')) # <re.Match object; span=(0, 7), match='abc\n123'>
str1 = 'and123hu\n123aaa\n456klk98ll7hu\n123oop'
re_str = r'(?s)\d+'
print(re.findall(re_str, str1)) # ['123', '123', '456', '98', '7', '123']
2.re模块
from re import compile, fullmatch, match, search, findall, finditer, split, sub
from re import IGNORECASE, MULTILINE, DOTALL, S
2.1 re.compile()
compile(正则表达式) - 编译正则表达式，创建正则表达式对象
re_obj = compile(r'\d{3}')
fullmatch(r'\d{3}', '234') # 等价于..
re_obj.fullmatch('234')
search(r'\d{3}', 'hu23hjk890jhkh78')
re_obj.search('hu23hjk890jhkh78')
2.2 匹配
1)fullmatch(正则表达式, 字符串) - 让整个字符串和正则表达式进行匹配
2)match(正则表达式, 字符串) - 匹配字符串开头
如果匹配不到结果是None,如果匹配成功了结果是匹配对象
re_str = r'\d{3}'
print(fullmatch(re_str, '732'))
print(fullmatch(re_str, '732hjas')) # None
print(match(re_str, '789')) # <re.Match object; span=(0, 3), match='789'>
print(match(re_str, '789j手机打开')) # <re.Match object; span=(0, 3), match='789'>
设置同时忽略大小写和单行匹配
print(fullmatch(r'123.[a-z]{3}', '123\nHNA', flags=S|IGNORECASE)) # <re.Match object; span=(0, 7), match='123\nHNA'>
print(fullmatch(r'(?is)123.[a-z]{3}', '123\nHNA')) # <re.Match object; span=(0, 7), match='123\nHNA'>
2.3 匹配对象
\# result = match(re_str, '789j手机打开')
re_str = r'(\d{2})-([a-z]{3})'
result = match(re_str, '23-sjm回款及时发货')
print(result)
1)获取匹配到的字符串
匹配对象.group() - 获取整个正则表达式匹配到结果
print(result.group()) # 23-sjm
匹配对象.group(分组号) - 获取正则表达式中指定的分组匹配到的结果(分组号从1开始)
print(result.group(1)) # 23
print(result.group(2)) # sjm
2)获取匹配到的子串的范围
匹配对象.span()
print(result.span()) # (0, 6)
print(result.span(2)) # (3, 6)
3)获取原字符串
匹配对象.string
print(result.string)
2.4 查找
1）search(正则表达式,字符串) - 在字符串中查找第一个能和正则表达式匹配的子串。如果找到了返回匹配对象，找不到返回None
findall(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串。返回一个列表，列表中的元素是字符串
finditer(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串。返回一个迭代器，迭代器中的元素是匹配对象
str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
result = search(r'\d+', str1)
print(result) # <re.Match object; span=(3, 6), match='123'>
result = findall(r'\d+', str1)
print(result) # ['123', '123', '456', '98', '7', '123']
result = findall(r'\d+[a-z]', str1)
print(result) # ['123a', '456k', '7h', '123o']
findall正则中如果有分组，只获取分组匹配到的内容
result = findall(r'(\d+)[a-z]', str1)
print(result) # ['123', '456', '7', '123']
result = findall(r'(\d+)([a-z])', str1)
print(result) # [('123', 'a'), ('456', 'k'), ('7', 'h'), ('123', 'o')]
str2 = '9h3jabc===9k2mabc9293h0oabc==!!!'
result = findall(r'(\d[a-zA-Z]){2}abc', str2)
print(result)
result = finditer(r'((\d[a-zA-Z]){2})abc', str2)
\# print(list(result))
for x in result:
print(x.group(1))
2.5 切割
split(正则表达式, 字符串) - 将字符串中能和正则表达式匹配的子串作为切割点，对字符串进行切割。返回值是列表，列表中的元素是字符串
split(正则表达式, 字符串, 次数) - 指定切割次数
str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
result = split(r'\d+', str1)
print(result) # ['and', '=hu', 'aaa', 'klk', '!ll', 'hu', 'oop']
result = split(r'\d+', str1, 3)
print(result) # ['and', '=hu', 'aaa', 'klk98!ll7hu123oop']
2.6 替换
sub(正则表达式, 字符串1, 字符串2) - 将字符串2中能和正则表达式匹配的子串全部替换成字符串1
sub(正则表达式, 字符串1, 字符串2, 次数) - 限制替换次数
str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
new_str1 = sub(r'\d+', '+', str1)
print(new_str1) # and+=hu+aaa+klk+!ll+hu+oop
sentence = '你丫是傻 叉吗? 我操你大爷的. F u c k you.'
re_str = r'(?i)[操肏艹草曹]|f\s*u\s*c\s*k|s\s*h\s*i\s*t|傻\s*[比屄逼叉缺吊屌]|煞\s*笔'
new_sentence = sub(re_str, '*', sentence)
print(new_sentence)
3.编程思想
面向过程编程(穷人的思想)：一遇到问题马上想到的是怎么写代码把这个功能实现(逻辑)
函数式编程(小资的思想)：一遇到问题马上想到有没有一个函数已经把这个功能实现了，如果有就拿过来用，没有就定义一个有这个功能的函数(函数)
面向对象编程(富豪的思想)：一遇到问题马上想到有没有一个类中有这个方法能够把这个功能实现，如果没有就创建这个类(类和对象)
a = 10
b = 20
求变量a和b的和
print(a + b)
4.类和对象
4.1 什么是类、什么是对象
类就是拥有相同属性和相同功能的对象的集合（抽象）
对象就是类的实例(具体)
从生活的角度：
如果人是类， 余婷就是对象，骆老师是另一个对象
如果杯子是类，我桌上的这个杯子就是对象
4.2 定义类(说清楚共同属性和功能是哪些)
语法：
class 类名:
类的说明文档
类的内容(包含属性和方法)
说明：
class - 关键字
类名 - 程序员自己命名
要求：标识符,不能是关键字
规范：驼峰式命名，并且首字母大写;见名知义；不适用系统的函数名、类名、模块名
类的说明文档 - 用""""""引起来的说明性文字，主要说清楚类提供了哪些属性和哪些功能
类的内容 - 主要包含属性和方法(定义在类中的函数叫方法)
PEP8命名规范
student_name = '张三'
驼峰式命名
studentName = '李四'
定义一个人类
class Human:
"""人类"""
def eat(self):
print('人类在吃饭')
def sleep(self):
print('人类睡觉！')
class Servant:
"""佣人类"""
def wash(self):
print('洗衣服')
def cook(self, food):
print(f'做{food}')
4.3 定义对象(创建对象)
语法：
类名()
说明:
类名 - 是已经定义好的类的类名
p1 = Human() # 创建人类的对象p1
p2 = Human()
print(p1)
print(p2)
s1 = Servant() # 创建佣人类的对象s1
print(s1)
s2 = Servant()
s1.wash()
s2.wash()
s1.cook('面条')
s2.cook('包子')
4 方法
4.1 方法（定义在类中函数）
类中的方法分为三种：对象方法、类方法、静态方法
1)对象方法
怎么定义：直接定义在类中函数就是对象方法
特点：自带参数self(self在通过对象调用的时候不用传参, 系统会自动将当前对象传给self)，谁调用指向谁
怎么调用：用对象去调用(对象.方法名())
2)类方法
怎么定义: 定义函数前加装饰器 @classmethod
特点：自带参数cls(cls在通过类调用的时候不用传参，系统会自动将当前类传给cls)
怎么调用：用类调用(类.方法名())
3)静态方法
怎么定义: 定义函数前加装饰器 @staticmethod
特点：没有默认参数
怎么调用：用类调用
4)对象方法、类方法和静态方法怎么选：
如果实现函数的功能需要用到对象的属性，就选对象方法
class Dog:
\# eat是对象方法
def eat(self):
# self = dog1
print(f'self:{self}')
print('狗啃骨头')
\# count是类方法
@classmethod
def count(cls):
# Dog能做的cls都能做
print(f'cls:{cls}')
dog2 = Dog()
dog3 = cls()
print(dog2, dog3)
print('狗的数量是: 100')
@classmethod
def func(cls):
print('类方法')
\# func2是静态方法
@staticmethod
def func2():
print('静态方法')
\# 创建对象
dog1 = Dog()
print(f'dog1:{dog1}')
\# 用对象调用对象方法
dog1.eat()
\# 用类调用类方法
Dog.count()
\# 用类调用静态方法
Dog.func2()
print('=========================注意：======================')
\# 从本质上讲，类中的所有的方法都可以用对象和类调用，但是不能这么做
Dog.eat(12) # 如果用类调用对象方法，self就会变成普通的参数，没有存在的价值
dog1 = Dog()
dog1.count() # 用对象调用类方法的时候cls指向的还是类(不会指向对象)
dog1.func2()
Dog.func2()
6.init方法
6.1 构造方法
构造方法: 函数名和类名是一样的，用来创建对象的方法就是构造方法（Python中的构造方法，在定义类的时候系统已经自动创建好了）
6.2 init方法
init方法又叫初始化方法，用来在创建对象的是对对象进行初始化操作的。
当我们通过类创建对象的时候，系统会自动调用init方法来对象创建出来的对象进行初始化。
调用构造方法创建对象的时候需不需要参数，需要几个，看被自动调用的init
class Person:
def __init__(self, a, b):
print('初始化方法:', a, b)
print(f'self:{self}')
p1 = Person(10, 20)
print(p1)
\# p2 = Person(a=100, b=200)
\# p2 = Person()
def Person(*args, **kwargs):
对象 = 申请空间创建对象
对象.__init__(*args, **kwargs)
return 对象
7.对象属性
7.1 属性: 对象属性和类属性
对象属性: 对象属性的值会因为对象不同而不一样
a.定义在init方法中
b.以 self.属性名 = 值
c.通过 对象.属性名 的方式使用属性
class Person:
def __init__(self, name1, age1, gender1='男'):
self.name = name1
self.age = age1
self.gender = gender1
def eat(self):
print(f'{self.name}吃饭')
p1 = Person('小明', 1)
print(p1.name, p1.age, p1.gender)
p2 = Person('小花', 3, '女')
print(p2.name, p2.age, p2.gender)
p2.name = '大花'
print(p2.name)
\# p1.eat()
p2.eat()
