位操作宏定义
 
我们在写C语言时，经常需要用到位操作，但是每次自己使用逻辑运算符进行操作的时候，很费脑子，试试下面几个宏定义吧：
 
#define GET_BIT(value,bit) ((value)&(1<<(bit)))    //读取指定位
#define CPL_BIT(value,bit) ((value)^=(1<<(bit)))   //取反指定位

#define SET0_BIT(value,bit) ((value)&=~(1<<(bit))) //把某个位置0
#define SET1_BIT(value,bit) ((value)|= (1<<(bit))) //把某个位置1
 
位操作函数
 
这4个宏定义已经可以在大部分场合使用了，但是这个4个宏定义貌似功能也没事很全。
 比如要操作寄存器的某些位，但是又不改变其他位怎么办呢，试试如下的函数吧：
 
//设置数据的某些位的值
/*
value 需要设置的数据的指针
bitl 需要设置的位的低位
bith 需要设置的位的高位
data 需要设置的数据
*/

void SET_DATA(unsigned int *value,unsigned int bitl,unsigned int bith,unsigned int data)
{
    unsigned int* v = value;
    if(bitl<=bith)  
    {
        unsigned int bcount = bith-bitl+1;
        unsigned int cbit=0;
        unsigned int cdata=0;
        for(unsigned int i=0;i<bcount;i++)
        {
            cdata |=(1<<i);
            cbit  |=(1<<(bitl+i));
        }
        (*v)  &=~(cbit); 
        (*v)  |=((data&cdata)<<bitl); 
    }
}
 
使用方法: 例如 变量Value 的初始值为0xFF，要设置Value 的 0 到 5位 为 2 ，那么就调用函数:
 
	int Value = 0xFF;
	SET_DATA(&Value,0,5,2);

#每天一点点#
 python def 定义函数，调用函数
 
def sum_2_nums(a,b):  #def 定义函数
    result = a+b
    print('%d+%d=%d'%(a,b,result))

num1 = int(input('请输入第一个数字：'))
num2 = int(input('请输入第二个数字：'))   
sum_2_nums(num1,num2)   #调用函数
 
定义和调用的函数，1：个数相同 ；2：顺序 一 一对应
 这样才能正确实现
 

函数 def定义函数
    必须参数
    不定长参数：def add（*args） add(1,2,3,4,5)无命名参数 元组
                def add（**args）print_info ('wenson',30,‘male’）把键值对入到字典里储存
     关于不定长参数的位置：*args放在左边，**kwargs参数放在右边
     没有名字的值传给元组，有名字的传到字典，有不定长参数的默认参数放左边，没有放右边
     返回值：
     #返回值
# def f():
#     print('ok')
#     return 10 #作用：1 结束函数 ，2 返回一个对像
# a=f()
# print(a)
# def add(*args): #注意点：1.函数如果没有return，会默认返回一个None
#                         #2.如果return多个对象，那么python会把多个对象封装成一个元组返回
#     Sum=0
#     for i in args:
#         Sum+=i
#     print(Sum)
#     return Sum
# a=add(1,2,3,4,5)
# print(a)

#作用域：built_in 内置作用域----global全局作用域---enclosin嵌套作用域--local本地作用域
#只有模块、类、及函数才能引入新作用域
#内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字
#nonlocal是python3新增的关键字
# count = 10
# def outer():
#     print(count)
# outer()

#递归函数:1.调用自身函数，2.有一个结束条件，3.但凡是递归可以写的循环都可以实现，效率不高
# def f(n):
#     sum_f = 1
#     for i in range(1,n) :
#         sum_f = sum_f*i
#         return sum_f
# print(f(7))
#
# def fac (n):
#     if n==1:
#         return 1
#     return n*fac(n-1)
# print(fac(9))
#斐波那契# 数列
# def fibo(n):
#   if n==0 or n==1:
#       return n
#   return fibo(n-1)+fibo(n-2)
# print(fibo(9))
#重要内置函数
# filter#过虑器
# str=['a','b','c','d']
# def fun1(s):
#     if s!='a':#过虑‘a’
#         return s
# ret = filter(fun1,str)
# print(ret)#<filter object at 0x0000000001051C88>ret是一个迭代器对象
# print(list(ret))#['b', 'c', 'd']

# map#修改器
# str=['a','b','c','d']
# def fun2(s):
#     return s +"alvin"#['aalvin', 'balvin', 'calvin', 'dalvin']
# ret = map(fun2,str)
# print(ret)#map objectr 迭代器
# print(list(ret))

# #reduce #叠加器
# from functools import reduce
#
# def add1(x,y):
#     return x+y
# print(reduce(add1,range(1,101)))#结果就是一个值

#lambda 匿名函数
from functools import reduce
print(reduce(lambda a,b :a*b,range(1,6)))

概念
 
在预编译阶段完成代码替换。
 
优势
 
(1)增加代码的可读性：
 
宏定义的优点很多，但我个人理解宏定义最明显的优点就是增加代码的可读性。求圆的面积， 用“PI * r* r”比 “3.14人r”的可读性就强很多了。
 
#define PI 3.14

float circleArea(float r) {
  return PI * r * r;
}
 
(2)自带“模版函数”的buff:
 
宏定义函数的参数没有数据类型，因此可轻松实现模板函数的功能
 
#define MAX(a, b) (a > b ? a : b)

std::cout << "max of a and b is: " << MAX(1, 2)  << std::endl;
std::cout << "max of a and b is: " << MAX(1.5, 2.1) << std::endl;
 
(3)相比于正常函数，宏定义函数性能更快
 
宏定义的本质决定了这个优势，宏定义只是在代码编译阶段做一个简单的替换，没有任何语法和优化的空间，因此宏定义函数没有正常函数所需的开销，包括：开辟空间，记录返回地址，形参压栈，从函数中返回释放堆栈。
 
缺点#define SUM(a,b) a+b
 
1 宏定义函数只能完成一些简单的替换，因此他的使用场景是有限制的，即使是宏定义函数， 也只是完成简单的功能， 不能真正的替代函数。
2 由于只是做一个替换，因此使用的时候需要谨慎，避免出现符号优先级而出现的低级错误。
 
#define SUM(a,b) a+b
std::cout << "area of rectangle: " << 2 * SUM(1, 2) << std::endl;
// 打印的结果是4， 而不是6.因此替换后的代码：
2 * 1 + 2， 而不是2 * （ 1+ 2）  
 
一个惯用的用法
 
用do{}while(0)包裹宏定义函数中的代码，这样的好处就是方便实现很复杂的宏定义函数，还可以把这个宏定义函数伪装成一个正常的函数去执行。
 如下例：
 
#define UNIT_AREA(shape)               \
  do {                                 \
    if (shape == "circle") {           \
      std::cout << PI << std::endl;    \
    } else if ( shape == "square") {   \
      std::cout << "1" << std::endl;   \
    } else {                           \
      std::cout << "1.0" << std::endl; \
    }                                  \
  } while(0)
 
 std::cout << "area of unit area: " << std::endl;
 UNIT_AREA("circle");
 
宏定义函数中的特殊符号
 
(1) …和__VA__ARGS__
 
支持宏定义就函数中的可变参数，宏定义参数可变，或者部分参数可变。
 使用“…”配合“VA_ARGS”。
 
#define  LOG(...) {printf("%s\n", __VA_ARGS__);}
#define  ERROR_LOG(x, ...) if (x) {printf("%s\n", __VA_ARGS__);}

// 以下代码皆可执行
 LOG("this is log")
 LOG("this is log");
 ERROR_LOG(1, "this is error log");
 {printf("log");}
 {printf("log");};
 
连接符：##
 
待写