对于函数的初步认识
在c语言的学习中，我们认识到了一个新的知识——函数。在数学中有过对函数的定义，我想大家都知道，但是在C语言中，函数的概念和数学中定义的函数概念一样吗？

其实本质上是一样的，我们知道数学中引入函数是为了解决一系列含有一对一或多对一的映射问题，而C语言中也是一样，我们所写的函数，则是解决我们需要解决的问题。当然，大家肯定也都知道C语言中有函数库，里面为我们提供大量的常用函数，不过值得了解的是，在早期的c语言中，是没有函数库的，当时人们对于某个尝用问题所写的函数不一样，为了统一，这才有了函数库，像我们知道的printf,scanf等都是函数库中的函数。由此看来，我们所写的函数对于解决我们要解决的问题则起着决定性作用，那么接下来我们走进对函数的了解吧
函数的基本定义
首先，想要了解函数，就先需要知道如何用C语言去定义函数，为此我写了一个较为简单的函数如下。
#include<stdio.h>
void Print(int Number)
{
  printf("%d\n",Number);
}
int main()
{
  int Num = 0;
  scanf("%d",&Num);
  printf("%d\n",Num);
  Print(Num);
  return 0;
}

如果我输入20则运行结果如下图



对此，大家是不已经有些许自己对函数的初步想法。

首先在主函数中输入20后，第一条printf语句打印出20，接下来遇到了语句print(Num),然后又打印出一个20，有的人可能就有疑惑了，明明只有一个printf语句，怎么会再打印出20？这是我们再看主函数上方有一个void print(int Number)，在这个大括号中包含一句printf的语句，看样子应该是这句话再打印出一个20.

在此，我告诉大家，void print(int Number)这就是一个函数。它包含了参数类型，函数名字以及是否有返回值这三个主要的东西。

这也就不难知道，主函数调用函数的时候，我们需要写入函数名，并在函数名后的小括号中写入需要向这个函数传入的参数，例如上面这个代码，我们就向函数Print中传入了一个名为Num的参数，则在我们所写的函数中就会接收到这个参数，并且执行函数中的语句，最后打印出20。
实参与形参
在C语言中，函数的参数可出现在两个地方，分别为函数定义处和函数调用处，但是这两个地方的参数是有不同的区别的。

在函数定义时，我们在后面定义的一个或多个参数，就是形式，参数简称形参，而在函数调用时，我们在所调用的函数名后的括号中，写入的一个或多个参数，是实实在在存在的参数，则叫做实际参数，简称实参。如下展示代码
#include<stdio.h>
void Print(int Number) //Number为形式参数
{
  printf("%d\n",Number);
}
int main()
{
  int Num = 0;
  scanf("%d",&Num);
  printf("%d\n",Num);
  Print(Num);//Numw为实际参数
  return 0;
}

通过定义便可知，主函数中在函数print调用处的Num为实际参数，是我们实实在在输入进去的参数，而在上面函数定义处的Number则为形式参数。形参和实参的功能是传递数据，发生函数调用时，实参的值会传递给形参。可以理解为形参是实参拷贝的一份。为使大家更好理解我们看以下代码
#include<stdio.h>
void My_Swap(int Number1,int Number2)
{
  int Temp = 0;
  Temp = Number1;
  Number1 = Number2;
  Number2 = Temp;
}
int main()
{
  int Num1=10,Num2=20;
  printf("Num1=%d,Num2=%d\n",Num1,Num2);
  My_Swap(Num1,Num2);
  printf("Num1=%d,Num2=%d\n",Num1,Num2);
  return 0;
}

大家不难看出所写的是一个交换寒素，想要把主函数中的Num1的值和Num2的值进行交换，但是运行结果如下



并没有将这两个值进行交换，是因为在所写的交换函数中，传入的是形式参数，并不是实际参数本身，形式参数的值与实际参数的值一模一样，但是他们的地址却不一样，如果想要将上述的两个值进行改变，则需要用到指针，代码，运行结果如下
#include<stdio.h>
void My_Swap(int *Number1,int *Number2)//用指针接收
{
  int Temp = 0;
  Temp = *Number1;
  *Number1 = *Number2;
  *Number2 = Temp;
}
int main()
{
  int Num1=10,Num2=20;
  printf("Num1=%d,Num2=%d\n",Num1,Num2);
  My_Swap(&Num1,&Num2);//传入地址
  printf("Num1=%d,Num2=%d\n",Num1,Num2);
  return 0;
}


函数的返回值
在上述的函数中，我们看到都是在所写的函数中执行语句并且输出。那么问题来了，如果用所写的函数计算得到一个结果，想要让主函数收到这个结果，该怎么实现呢？这就需要用到函数的返回值，首先，举个例子，我想要计算15+30的值，则代码如下
#include<stdio.h>
int Add(int Number1,int Number2)
{
  int Sum = Number1 + Number2;
  return Sum;
}
int main()
{
  int Num1 = 15,Num2 = 30,sum = 0;
  sum = Add(Num1,Num2);
  printf("%d + %d = %d\n",Num1,Num2,sum);
  return 0;
}

运行结果如下图



我们发现得出正确答案。那么是怎么实现的呢？

看到与之前写的函数不同的是，void变成了int，而这便是函数的返回类型，因为我们得到的答案是一个整型，所以这里需要用int，那是怎么返回的呢，可以看到函数中最后一句我为return  Sum,这句话便把函数所计算的结果返回给主函数，这时，主函数中需要有个一变量接收这个参数，不难发现也需要用整型进行接收，在此我们知道，主函数的接收类型和函数的返回类型要一置。

当然，返回值可以时变量也可以时一条语句也可以是一个常数，也可以是函数。

比如上述代码可以把部分语句做如下替换
  return Sum;//替换如下
  return Number1 + Number2;
  printf("%d + %d = %d\n",Num1,Num2,sum);//替换如下
  printf("%d + %d = %d\n",Num1,Num2,Add(Num1,Num2));

函数的递归
接下来，就要给大家讲一讲函数的递归。什么是递归？刚才我说函数的返回值除了可以是变量，常数，一条语句，也可以是函数。其中如果这个返回值是函数的话并且是函数它本身，那么就可以理解为自己调用自己，而这就是递归。

递归需要有条件限制，不能无限制递归下去，这样就成了死递归，并且还要有跳出递归的条件，每次递归的时候需要接近这个跳出条件。

为了方便理解，现有如下计算n的阶乘代码
#include<stdio.h>
int Jie_Cheng(int Number)
{
  if(Number==1) return 1;
  else{
    return Number*Jie_Cheng(Number-1);
  }
}
int main()
{
  int Num=0;
  scanf("%d",&Num);
  printf("%d！= %d\n",Num,Jie_Cheng(Num));
  return 0;
}

输入5后运行结果如下图



那么，这是怎么计算的呢？首先5作为形式参数传入函数后，付给Number，因为5>1所以第一条if语句没有进去，走else语句，我们发现号后面便是函数自己，于是又进入该函数，此时新的形式参数值变为了4，因为4>1于是又走else语句，再号后面又是函数本生，如此循环，直到Number=1时进入if条件句，此时return 1,则开始逐层跳出，因为刚才该函数调用了自己很多次，当遇到该跳出递归的条件时，便需要一层一层跳出，最后返回的结果实际上就是54321。

同样的如下递归求字符串长度代码
#include<stdio.h>
int My_Strlen(char *Str)
{
  if(*Str!='\0')
  return My_Strlen(Str+1)+1;
}
int main()
{
  char St[100];
  scanf("%s",&St);
  printf("%d\n",My_Strlen(St));
  return 0;
}


输入abcdef后运行结果如下



同理，也是通过递归跳出条件进行判定，如果其不为’\0’则表示长度加一，使Str+1即地址加一继续判定，当读到’\0’时，满足跳出递归条件，则一层一层的跳出，最后计算结果为7。

至此，递归的讲解就到这里，如果大家对递归感兴趣的话，可以了解以下汉诺塔问题等，谢谢大家的阅读

1、Hash的概念 
将任意长度的输入通过散列算法之后映射成固定长度的输出。@头条创作者变现小助手 @头条搜索 
2、Hash冲突 
当关键字集合很大时(key的数量很多的时候)，关键字值不同的元素可能会映像到哈希表的同一地址上，即K1!=K2，但f(K1)=f(K2),这种现象称为hash冲突，实际中冲突是不可避免的，只能通过改进哈希函数的性能来减少冲突。#java开发工程师# 
3、你认为好的Hash算法的点应该有哪些？ 
(1)效率得高，做到长文本也能高效计算出Hash值
(2)根据Hash值不能逆推出原文
(3)两次输入，如果有一点不同也得保证Hash值是不同的
(4)尽可能要分散，因为在table中slot大部分都处于空闲状态时要尽可能降低Hash冲突
4、HashMap的存储结构长啥样？
JDK1.8：
(1)数组+链表+红黑树构成，每个数据单元为一个Node结构，Node结构中有key字段、value字段、next字段、hash字段
(2)next字段就是发生Hash冲突的时候，当前桶位中的Node与冲突Node连接成一个链表所需要的字段
JDK1.7：数组+链表
45、如果创建HashMap的时候没有指定HashMap散列表的长度，初始长度为多少？
在JDK 8中，关于默认容量的定义为：static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //16 ，其故意把16写成1<<4，就是提醒开发者，这个地方要是2的幂。
(1)为啥用位运算呢？直接写16不好么？
这样是为了位运算的方便，位与运算比算数计算的效率高了很多，之所以选择16，是为了服务将Key映射到index的算法。(2)那为啥用16不用别的呢？
因为在使用不是2的幂的数字的时候，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。这个值既不能太小，也不能太大。
太小了就有可能频繁发生扩容，影响效率，太大了又浪费空间，不划算。只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。
这是为了实现均匀分布。
6、散列表是New HashMap()的时候创建的，还是什么时候创建的？
散列表是懒加载机制，只有在第一次put数据的时候才创建(JDK1.8，JDK1.7是直接加载散列表)
7、负载因子默认是多少，有啥作用？为什么负载因子为0.75？什么时候进行扩容(resize)？
(1)默认为0.75，用于计算扩容阈值
(2)loadFactor是负载因子，表示HashMap满的程度，默认值为0.75f，设置成0.75有一个好处，那就是0.75正好是3/4，而capacity又是2的幂。所以，两个数的乘积都是整数。
(3)影响扩容主要有两个因素：
Capacity：HashMap当前长度。
LoadFactor：负载因子，默认值0.75f。
怎么理解呢，就比如当前的容量大小为100，当你存进第76个的时候，判断发现大于扩容阈值100*0.75=75需要进行resize了，那就进行扩容，但是HashMap的扩容也不是简单的扩大点容量这么简单的。8、扩容？它是怎么扩容的呢？
分为两步
(1)扩容：创建一个新的Entry空数组，长度是原数组的2倍。
(2)ReHash：遍历原Entry数组，把所有的Entry重新Hash到新数组。
为什么要重新Hash呢，直接复制过去不香么？
是因为长度扩大以后，Hash的规则也随之改变。
比如原来长度(Length)是8你位运算出来的值是2 ，新的长度是16你位运算出来的值明显不一样了。9、链表转化为红黑树的条件
(1)链表长度达到8
(2)当前散列表长度达到64
以上两个条件同时满足链表才会转化为红黑树，如果仅仅链表长度达到8，它不会发生链表转红黑树，只会发生一次散列表扩容(resize)10、Node对象里面的hash字段的值是key对象的hashcode的返回值吗？
不是的，通过key的hashcode的高16位异或低16位得到的新值，这样即使数组table的length比较小的时候，也能保证高低bit都参与到Hash的计算中，避免高16位浪费没起到作用，尽可能的得到一个均匀分布的hash。
11、为啥我们重写equals方法的时候需要重写hashCode方法呢？你能用HashMap给我举个例子么？
因为在java中，所有的对象都是继承于Object类。Ojbect类中有两个方法equals、hashCode，这两个方法都是用来比较两个对象是否相等的。
在未重写equals方法我们是继承了object的equals方法，那里的 equals是比较两个对象的内存地址，显然我们new了2个对象内存地址肯定不一样
比如发生Hash冲突的时候，我们去get，他就是根据key去hash然后计算出index，找到了2，那我怎么找到具体的”电脑“还是”脑电“呢？
equals！是的，所以如果我们对equals方法进行了重写，建议一定要对hashCode方法重写，以保证相同的对象返回相同的hash值，不同的对象返回不同的hash值。
12、HashMap的put数据的流程
13、为什么java8以后链表数据超过8以后，就改成红黑树存储？
这就涉及到拒接服务攻击了，比如某些人通过找到你的hash碰撞值，来让你的HashMap不断地产生碰撞，那么相同key位置的链表就会不断增长，当你需要对这个HashMap的相应位置进行查询的时候，就会去循环遍历这个超级大的链表，性能及其地下。java8使用红黑树来替代超过8个节点数的链表后，查询方式性能得到了很好的提升，从原来的是O(n)到O(logn)，容器中节点分布在hash桶中的频率遵循泊松分布，桶的长度超过8的概率非常非常小(约为10万分之一)，所以作者应该是根据概率统计而选择了8作为阀值。
14、Hashmap的结构，1.7和1.8有哪些区别？
(1)JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么他们为什么要这样做呢？
因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。(2)扩容后数据存储位置的计算方式也不一样：1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&(这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况时最后一位二进制数才一定是1，这样能最大程度减少hash碰撞)(hash值 & length-1)
15、首先HashMap是线程不安全的，其主要体现在哪里？
(1)在jdk1.7中，在多线程环境下，扩容时会造成环形链或数据丢失。
(2)在jdk1.8中，在多线程环境下，会发生数据覆盖的情况。

常用的一个分类的损失函数是：交叉熵函数
但是真的理解了吗？虽然之前做过图像分类，但是一直没有深入研究，我今天才真正的理解并且记住了它。
pytorch中的交叉熵函数在是 torch.nn中是 CrossEntropyLoss()。
对于二分类问题(一般 标签为 【0，1】)，交叉函数公式表示为：
在二分类中，我们通过神经网络的到一个映射值，随后会通过sigmoid函数，输出一个概率值，反映该样本是正例的可能性，即概率越大，可能性越大。(这里会有一个似然函数的概念，似然函数简单的理解就是 所有可能发生的可能性【记一下，后面补充更好的理解】)
sigmoid函数：
 将网络的输出映射到[0,1]之间的数值概率上，即为交叉熵函数中的那个预测概率输出( 
 )。 
 或预测输出表征当前样本label为1的概率：
因此样本label为0 时，概率为：
将上面的两个公式整理为:
希望
 越大越好，反之，需要让 
 的负值越小越好，由此引入了最初的损失函数。
对于多分类，就意味着对每个标签类别下的的可能概率分别求相应的
 并求和：
上面的二分类，可以用y,1-y代表1，0。多分类的时候要把类别各写各的，所以看起来变成了一半，其实是一样的！！！
在pytorch中使用 CrossEntropyLoss()时，不需要自己再做sigmoid或者softmax辽。参考下面这个博客，非常详细。要注意，target类型要转为torch.long().

前言
Python 的字典有好多个名称(”映射”、”哈希”、”散列”或者”关系数组”)，那你知道为什么字典会被称为 Hash(翻译为”哈希”或”散列”)吗？
你知道为什么字典对于键(Key)的存储数据要求比较严格，但对于对应的值(Value)的存储却要求很宽松吗？
读完这篇文章，你将深刻理解这些问题背后的真相！
hash
首先我们来解释一下什么是 Hash，来自维基百科：
散列函数(或散列算法，又称哈希函数，英语：Hash Function)是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做散列值的指纹。散列值通常用来代表一个短的随机字母和数字组成的字符串。好的散列函数在输入域中很少出现散列冲突。在散列表和数据处理中，不抑制冲突来区别数据，会使得数据库记录更难找到。
世界上没有两片完全相同的树叶，也没有两个相同的指纹，散列函数是用于从数据中创建小的数字指纹的方法。
我们看下图示：
如图，Python 调用内部的散列函数，将键(Key)作为参数进行转换，得到一个唯一的地址(这也就解释了为什么给相同的键赋值会直接覆盖的原因，因为相同的键转换后的地址是一样滴)，然后将值(Value)存放到该地址中。
对于 Python 来说，键(Key)必须是可哈希的，换句话说就是要可以通过散列函数计算出唯一地址的。那如果拿一个变量当键(Key)可以吗？肯定不行。因为变量随时都可能改变，不符合可哈希原则！
同样的，列表、字典、集合这些都是可变的，所以都不能做为键(Key)来使用。
那有朋友可能会问，那元祖呢？元祖总该是不变的吧？
其实不然，因为元祖里边可以存放列表这类可变因素，所以如果实在想拿元祖当字典的键(Key)，那必须对元祖做限制：元组中只包括像数字和字符串这样的不可变元素时，才可以作为字典中有效的键(Key)。
另外还需要注意的一点是，Python 的哈希算法对相同的值计算得到的结果是一样的，也就是说 12315 和 12315.0 的值相同，他们被认为是相同的键(Key)。
您可能感兴趣的文章:解决Python获取字典dict中不存在的值时出错问题python 实现将字典dict、列表list中的中文正常显示方法python 将字符串转换成字典dict的各种方式总结Python中字典(dict)合并的四种方法总结Python中如何优雅的合并两个字典(dict)方法示例Python把对应格式的csv文件转换成字典类型存储脚本的方法