反射 测试 排列组合

反射

1.概念

通过字符串操作对象中的字段【类的字段和对象的字段的 == 类属性和实例属性】
反射就是通过字符串的方式，导入模块，去模块中调用指定的函数；去到对象中操作【查找、获取、删除、添加】成员

本质：一直基于字符串的驱动

2.使用

getattr:获取属性
setattr:修改属性的值
hasattr:判断某个属性是否存在
delattr:删除某个属性

class Person(object):
    country = "CH"

    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def show(self):
        print("show")
    @classmethod
    def func1(cls):
        print("111")
    @staticmethod
    def func2():
        print("222")

#1.以往的用法
p1 = Person("jack",10)
print(p1.name)

#2.反射
#问题：通过一个字符串"name"获取jack，“age”获取10
print("name","age")

#方式一:__dict__
print(p1.__dict__)
print(p1.__dict__["name"])

#方式二：反射
#getattr(obj,name[,default])获取某个对象的某个字段的值，如果字段不存在，则返回default
r0 = getattr(p1,"name")
print(r0)
#r0 = getattr(p1,"score")  #AttributeError: 'Person' object has no attribute 'score'
r0 = getattr(p1,"score",100)
print(r0)

#私有化属性
# r0 = getattr(p1,"age")
# print(r0)
r0 = getattr(p1,"_Person__age")
print(r0)

#类属性
#对象或者类名访问类属性
r0 = getattr(Person,"country")
print(r0)
r0 = getattr(p1,"country")
print(r0)

#成员函数
r0 = getattr(p1,"show")
print(r0)
r0()

#类函数和静态函数
r0 = getattr(Person,"func1")
print(r0)
r0()
r0 = getattr(p1,"func1")
print(r0)
r0()

r0 = getattr(Person,"func2")
print(r0)
r0()
r0 = getattr(p1,"func2")
print(r0)
r0()

#3.setattr(obj,name,value)
p1 = Person("jack",10)
#p1.name = "zhangsan"

setattr(p1,"name","zhangsan")
print(getattr(p1,"name"))

#4.hasattr(obj,name)
print(hasattr(p1,"name"))
print(hasattr(p1,"score"))

#5.delattr(obj,name)
delattr(p1,"name")
#print(getattr(p1,"name"))  #AttributeError: 'Person' object has no attribute 'name'

模块中的反射

import  reflect02.moduleA


#1.以往的方式
print(reflect02.moduleA.num)

reflect02.moduleA.show()

a = reflect02.moduleA.A(47)

#2.反射
#Python中一切皆对象，模块也是一个对象
print(getattr(reflect02.moduleA,"num"))

s = getattr(reflect02.moduleA,"show")
s()

A = getattr(reflect02.moduleA,"A")
print(A)
r = A(36)
print(r.a)


num = 18

def show():
    print("aaaaa")

class A(object):
    def __init__(self,a):
        self.a = a

# 练习
# news
def video():
    return "视频"
def image():
    return "图片"
def games():
    return "游戏"
def music():
    return "音乐"
def movie():
    return "电影"


#需求：根据用户输入的内容，执行对应的操作

import  reflect03.news

#方式一
# data = input("请输入你要执行的操作：")
# if data == "music":
#     print(reflect03.news.music())
# elif data == "movie":
#     print(reflect03.news.movie())
# elif data == "games":
#     print(reflect03.news.games())
# elif data == "image":
#     print(reflect03.news.image())
# elif data == "video":
#     print(reflect03.news.video())
# else:
#     print("还未开通此功能")

#方式二
data = input("请输入你要执行的操作：")

result = hasattr(reflect03.news,data)
if result:

    f = getattr(reflect03.news,data)
    print(f())
else:
    print("还未开通此功能")


#总结：反射的好处：可以简化代码，提高了代码的可维护性

单元测试和文档测试

1、单元测试
指的是对一个函数，一个类或者一个模块来进行正确性的校验工作
结果;
　ａ．单元测试用过，说明所测试的单元时正常
　b．单元测试未通过，说明有bug,或是条件不成立

def mysum(x,y):
    return  x + y

def mysub(x,y):
    return  x - y

from  test01.mathfunc import mysum,mysub
import  unittest

#1.自定义测试类，继承自unittest.TestCase
class Test(unittest.TestCase):
    #2.重写父类中的函数
    def setUp(self):
        print("开始测试时自动调用")
    def tearDown(self):
        print("结束测试时自动调用")

    #3.定义成员函数，测试指定的函数
    #命名格式：test_需要被测试的函数名

    def test_mysum(self):
        #使用断言：对函数的结果做一个预判【代入法】
        #参数:调用原函数的结果   预判的结果  如果预测失败的提示信息

        #含义：用自己预判的结果和函数的运算结果做比对，如果相等，则说明测试通过
        self.assertEqual(mysum(1,2),3,"加法有误")

    def test_mysub(self):
        self.assertEqual(mysub(2,1),1,"减法有误")

#4.开始测试
if __name__ == "__main__":
    #调用main函数，会触发Test类中所有函数的调用
    unittest.main()

2、文档测试

import  doctest

def add(x,y):
    """
    求两个数的和
    :param x: 第一个数字
    :param y: 第二个数字
    :return: 和

    example:
    >>> add(2,3)
    5
    """
    return  x + y

print(add(10,43))

#开始进行文档测试
doctest.testmod()

#注意：必须严格按照命令行中的格式书写代码

排列组合

#排列：从n个不同的元素中取出m【m <= n】个元素，按照一定的顺序排成一列,
# 称为从n个元素中获取m个元素的排列【Arrangement】,当.m = n时，则成为全排列【Permutation】

"""
例如：
1 2 3 4，从中取出3个，排列的方式？
123
213
321
312
132
231

123  124  134  234
"""
import  itertools

#itertools.permutations(可迭代对象，num)
result = list(itertools.permutations([1,2,3,4],1))
print(result)

print(len(result))

"""
4-4   24
4-3    24
4-2    12
4-1    4

从n个元素中取出m个元素的排列的可能性：n! / (n - m)!
"""

#组合：从n个不同的元素中，取出m个元素为一组，叫做从n个不同元素中取出m个元素的组合

import  itertools

result = list(itertools.combinations([1,2,3,4],3))
print(result)
print(len(result))

"""
4-4    1
4-3    4
4-2     6
4-1     4

从n个不同元素中取出m个元素的组合的可能性：n！/ (m! * (n -m)!)
"""

import  itertools


#验证码
#
result = list(itertools.permutations("0123456789",6))
# #print(result)
# print(len(result))
#
# result = list(itertools.product("0123456789",repeat=6))
# #print(result)
# print(len(result))

#密码
#result = list(itertools.permutations("0123456789qwertyuioplkjhgfdsazxcvbnm",6))
#print(result)
#print(len(result))

result = list(itertools.product("0123456789qwertyuioplkjhgfdsazxcvbnm",repeat=4))
#print(result)
print(len(result))

正则表达式

1.案例

需求：校验一个qq号的合法性

需求：校验一个手机号的合法性

2.概念

正则表达式：Regular Expression,Python中提供一个模块为re

使用单个字符串来描述、匹配、查找或者替换指定字符串的操作

正则表达式的作用：

a.可以匹配：match

b.可以搜索:search,findall

c.可以替换：sub，subn

注意：正则表达式其实只是一个字符串，该字符串具有一定的规律，使用特定的符号来匹配特定的内容

使用场景：校验数据【qq号，手机号，身份证号，银行卡号，用户名和密码，邮箱等】

		    爬虫【按照指定的条件将一个网页中的指定的数据筛选出来】