Python-函数基础总结与内置函数

文末有福利领取哦~

👉一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉二、Python必备开发工具

👉三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

👉 四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。（文末领读者福利）

👉五、Python练习题

检查学习结果。

👉六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file:  a file-like object (stream); defaults to the current sys.stdout.
sep:   string inserted between values, default a space.
end:   string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
"""
pass

 作用是将值打印到流或系统标准输出（默认情况下）。


值使用逗号隔开，后面有几个默认参数（后面讲），我们常用的是sep和end，一个用来分隔值，一个用于末尾。


不填默认值时：



> 
> >>> print('lady','killer')  
>  lady killer
> 
> 
> 


 使用关键字参数填写默认值（后面讲）



> 
> >>> print('lady','killer',sep=';')  
>  lady;killer  
>  >>> print('lady','killer',end=';')  
>  lady killer;>>>
> 
> 
> 


参数数量不对，关键字错误，类型错误等会显示TypeError



> 
> >>> print('lady','killer',edn=';')  
>  Traceback (most recent call last):  
>    File "<stdin>", line 1, in <module>  
>  TypeError: 'edn' is an invalid keyword argument for print()
> 
> 
> 


 ()操作符是函数调用，函数的名字你可以认为是指针/引用，函数名字后面有()时，函数体内的代码才会运行。



> 
> >>> display=print  
>  >>> display('lady','killer')  
>  lady killer
> 
> 
> 


上面代码我使用display变量让其指向print所指的函数，再使用()调用函数也可进行输出。()操作符在面向对象时也可用作类的实例化。


### 传参是值传递还是引用传递


**代码：**

def function(x, lst):
print(‘函数内x修改前:’, id(x), x)
print(‘函数内lst修改前:’, id(lst), lst)
x += 1
lst.append(x)
print(‘函数内x修改后:’, id(x), x)
print(‘函数内lst修改后:’, id(lst), lst)
return x, lst

x = 3
lst = [3]
print(‘函数外x调用前:’, id(x), x)
print(‘函数lst外调用前:’, id(lst), lst)
x_return, lst_return = function(x, lst)
print(‘函数外x调用后:’, id(x), x)
print(‘函数外lst调用后:’, id(lst), lst)
print(‘返回的x:’, id(x_return), x_return)
print(‘返回的lst:’, id(lst_return), lst_return)

**结果：**



> 
> 函数外x调用前: 140730711241024 3  
>  函数lst外调用前: 1739892740680 [3]  
>  函数内x修改前: 140730711241024 3  
>  函数内lst修改前: 1739892740680 [3]  
>  函数内x修改后: 140730711241056 4  
>  函数内lst修改后: 1739892740680 [3, 4]  
>  函数外x调用后: 140730711241024 3  
>  函数外lst调用后: 1739892740680 [3, 4]  
>  返回的x: 140730711241056 4  
>  返回的lst: 1739892740680 [3, 4]
> 
> 
> 


传参引用传递：修改前与调用前的id一样


返回引用传递：修改后与返回的id一样


不可变类型变量x，传参引用传递，返回引用传递，由于不可变，故指向3和4的变量都叫x（实参和形参），我们输出的修改后的x是指向4的x，指向3的x**未变**。


可变类型变量lst，传参引用传递，返回引用传递，由于可变，故id一直不变。


总结：函数传参是引用传递，函数外一直不变，对于不可变类型，可以通过返回修改后的引用来改变它（指向其他地方）。


## 定义函数


### 参数


#### 默认参数


我们定义一个简单的求x的n次幂的函数：

def power(x, n):
return x ** n
print(power(2, 2))
print(power(3, 2))
print(power(4, 2))
print(power(2, 3))

得到结果：



> 
> 4  
>  9  
>  16  
>  8
> 
> 
> 


 我们定义了一个返回x的n次幂的函数，调用函数的人说，我大部分情况下都是想要x的平方，我懒得写2，这个时候你~~让他滚~~可以使用默认参数。

def power(x, n=2):
return x ** n

print(power(2))
print(power(3))
print(power(4))
print(power(2, 3))

这样，得到一样的结果，当参数特别多而有些参数大部分情况下不会改变时可以使用默认参数，也可以增强函数的健壮性。


**注意：** 默认值只会**执行一次**。这条规则在默认值为**可变对象**（列表、字典以及大多数类实例）时很重要。比如，下面的函数会存储在后续调用中传递给它的参数:

def f(a, L=[]):
L.append(a)
return L

print(f(1))
print(f(2))
print(f(3))

结果为：

[1]
[1, 2]
[1, 2, 3]

如果你不想要在后续调用之间共享默认值，你可以这样写这个函数:

def f(a, L=None):
if L is None:
L = []
L.append(a)
return L

#### 关键字参数


关键字参数在调用函数时使用过了，使用形如 `kwarg=value` 的关键字参数来调用函数。像print('lady','killer')是**位置参数**，python会根据参数前后位置进行匹配，关键字参数必须跟随在位置参数的后面，否则会出现语法错误，例如：



> 
> >>> display(sep=';','killer')  
>    File "<stdin>", line 1  
>  SyntaxError: positional argument follows keyword argument
> 
> 
> 



> 
> >>> display('lady','killer',end=';',sep='&')  
>  lady&killer;>>> 
> 
> 
> 


关键字参数之间是不需要按定义函数时的顺序填写的（此时，我的display和print在交互式命令窗口是一样的）。


#### 参数组


这个时候调用函数的人说，我需要你完成一个复杂的函数，有**很多的参数**，你可以~~说老子辞职不干了~~使用参数组对参数进行打包。python 提供了两种，一种是元组，就是你经常看到的\*args，另一个是字典，就是你经常看到的\*\*kwargs。


在前面我们提到的print函数就把需要输出的很多value打包成了一个元组。


我们定义一个学生函数，打印学生的id、科目分数，总分和其他信息。

def student(id, *subjects, **more_info):
print(‘id:’, id)
print(‘math:’, subjects[0])
print(‘english:’, subjects[1])
print(‘allscore:’, sum(subjects))
print(‘name:’, more_info[‘name’])
print(‘school:’, more_info[‘school’])
print(‘classroom:’, more_info[‘classroom’])

student(2, 80, 99, name=‘frank’, school=‘computer’, classroom=‘1114’)

结果为：



> 
> id: 2  
>  math: 80  
>  english: 99  
>  allscore: 179  
>  name: frank  
>  school: computer  
>  classroom: 1114
> 
> 
> 


可以看到，python会自动的按照顺序填写好。


当然，大部分情况下是因为调用函数的人拥有的数据也是这个数据结构（得到的json数据等），此时可以这样调用：

subjects = (80, 99)
more_info = {‘name’: ‘frank’, ‘school’: ‘computer’, ‘classroom’: ‘1114’}
student(2, *subjects, **more_info)

print(*subjects)得到的是 80 99 而不是 (80,99)，因为print没把subject作为一个value，而是拆成了多个（这是列表、元组两篇文章埋下的坑）。

### 返回值


不像C++中函数前需要指定函数的返回值类型



> 
>  int plus(int a, int b) 
>    
>  { 
>    
>      return a+b; 
>    
>  } 
> 


python中函数可以不指定返回值的类型，也可以返回多个值，使用逗号分隔。

def sum_multiplication(a, b):
return a + b, a * b

res = sum_multiplication(2, 3)
print(res)

结果为：



> 
> (5, 6)
> 
> 
> 


可以看到返回值是一个元组，你也可以使用对应的个数直接解析到每个返回值

sums, multiplication = sum_multiplication(2, 3)
print(sums, multiplication)

结果为：



> 
> 5 6
> 
> 
> 


### 指定参数、返回值类型


使用冒号:和箭头->

def plus(a: int, b: int) -> int:
“”"
:param a: a number
:param b: a number
:return: a+b
“”"
return a + b

print(type(plus(3, 4)))
print(plus(3, 4))

结果：



> 
> <class 'int'>  
>  7
> 
> 
> 


传入字符串：

print(type(plus(‘3’, ‘4’)))
print(plus(‘3’, ‘4’))

结果：



> 
> <class 'str'>  
>  34
> 
> 
> 


![](https://img-blog.csdnimg.cn/20201019101742228.jpg)


pycharm给出警告，仅此而已，毕竟python是动态语言，看python源代码中的函数也没看见过指定，如果非要进行类型检查，你可以自己写，使用isinstance等函数判断。这个指定一般是在leetcode这样的oj网站经常出现。


## 内置函数


### 标准类型函数





 常用标准类型函数 
 | 函数 | 作用 |
| --- | --- |
| dir() | 如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。 |
| help() | 如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。 |
| id() | 返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的l值。 |
| len() | 返回对象的长度（元素个数）。 |
| str() | 返回一个str 版本的 *object* 。 |
| type() | 传入一个参数时，返回 *object* 的类型。 返回值是一个 type 对象，通常与object.\_\_class\_\_所返回的对象相同。 |


#### dir



> 
> >>> dir(list)  
>  ['\_\_add\_\_', '\_\_class\_\_', '\_\_contains\_\_', '\_\_delattr\_\_', '\_\_delitem\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_getattribute\_\_', '\_\_getitem\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_iadd\_\_', '\_\_imul\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_iter\_\_', '\_\_le\_\_', '\_\_len\_\_', '\_\_lt\_\_', '\_\_mul\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_reversed\_\_', '\_\_rmul\_\_', '\_\_setattr\_\_', '\_\_setitem\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
> 
> 
> 


#### help



> 
> >>> help(list.insert)  
>  Help on method\_descriptor:
> 
> 
> insert(self, index, object, /)  
>      Insert object before index.
> 
> 
> 


#### id



> 
> >>> a = 3  
>  >>> b = 3  
>  >>> id(a)  
>  140707324522816  
>  >>> id(b)  
>  140707324522816  
>  >>> b = 4  
>  >>> id(b)  
>  140707324522848
> 
> 
> 



> 
> >>> l = [1,2]  
>  >>> t = [1,2]  
>  >>> id(l)  
>  2141070401288  
>  >>> id(t)  
>  2141071612360  
>  >>> t=l  
>  >>> id(t)  
>  2141070401288
> 
> 
> 


不可变类型的id可能相同（我尝试的一直相同），可变类型一般赋值后才会相同。


#### len



> 
> >>> len(l)  
>  2
> 
> 
> 


#### str



> 
> >>> str(l)  
>  '[1, 2]'
> 
> 
> 


#### type



> 
> >>> type(l)  
>  <class 'list'>
> 
> 
> 


### 数字类型函数


#### 转换工厂函数





 数字类型函数 
 | 函数 | 作用 |
| --- | --- |
| bool(x) | 返回一个布尔值，`True` 或者 `False`。 *x* 使用标准的真值测试过程来转换。如果 *x* 是假的或者被省略，返回 `False`；其他情况返回 `True`。 |
| chr(i) | 返回 Unicode 码位为整数 *i* 的字符的字符串格式。 |
| float(x) | 返回从数字或字符串 *x* 生成的浮点数。 如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 `'+'` 和 `'-'` ;实参也可以是 NaN（非数字）、正负无穷大的字符串。 |
| hex(x) | 将整数转换为以“0x”为前缀的小写十六进制字符串。 |
| int(x,base=10) | 返回一个使用数字或字符串 *x* 生成的整数对象，或者没有实参的时候返回 `0` 。 |
| abs() | 返回一个数的绝对值。实参可以是整数或浮点数。如果实参是一个复数，返回它的模。 |
| `divmod`(*a*, *b*) | 它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 `(a // b, a % b)` 一致。对于浮点数，结果是 `(q, a % b)` ，*q* 通常是 `math.floor(a / b)` 但可能会比 1 小。 |
| `pow`(*x*, *y*[, *z*]) | 返回 *x* 的 *y* 次幂；如果 *z* 存在，则对 *z* 取余（比直接 `pow(x, y) % z` 计算更高效）。两个参数形式的 `pow(x, y)` 等价于幂运算符： `x**y`。 |
| `round`(*number*[, *ndigits*]) | 返回 *number* 舍入到小数点后 *ndigits* 位精度的值。 如果 *ndigits* 被省略或为 `None`，则返回最接近输入值的整数。 |


bool


返回False的有以下三类：


* 被定义为假值的常量: `None` 和 `False`。
* 任何数值类型的零: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`
* 空的序列和多项集: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`



> 
> >>> bool(None)  
>  False  
>  >>> bool(0)  
>  False  
>  >>> bool(())  
>  False  
>  >>> bool(l)  
>  True
> 
> 
> 


chr



> 
> >>> chr(97)  
>  'a
> 
> 
> 


chr的逆函数是ord


ord



> 
> >>> ord('a')  
>  97
> 
> 
> 


float



> 
> >>> float(1.23)  
>  1.23  
>  >>> float('-1.23')  
>  -1.23  
>  >>> float('2e-3')  
>  0.002  
>  >>> float('inf')  
>  inf
> 
> 
> 


hex



> 
> >>> hex(10)  
>  '0xa'  
>  >>> hex(-255)  
>  '-0xff'
> 
> 
> 


int



> 
> >>> int(23.5)  
>  23  
>  >>> int('010',8)  
>  8  
>  >>> int('010',16)  
>  16
> 
> 
> 


#### 功能函数


abs



> 
> >>> abs(-5)  
>  5  
>  >>> abs(-2.5)  
>  2.5
> 
> 
> 


divmod



> 
> >>> divmod(10,3)  
>  (3, 1)  
>  >>> divmod(10,2.5)  
>  (4.0, 0.0)
> 
> 
> 


pow



### 一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。



![](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)



### 二、学习软件

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。



![](https://img-blog.csdnimg.cn/img_convert/8c4513c1a906b72cbf93031e6781512b.png)



### 三、入门学习视频



我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。



![](https://img-blog.csdnimg.cn/afc935d834c5452090670f48eda180e0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56iL5bqP5aqb56eD56eD,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**