python基础语法与函数总结

01

Python

简介

Python 是一种高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 由 Guido van Rossum 于 1989 年底在荷兰国家数学和计算机科学研究所发明，第一个公开发行版发行于 1991 年。

python基础语法与函数总结

特点

• 易于学习：Python 有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
• 易于阅读：Python 代码定义的更清晰。
• 易于维护：Python 的成功在于它的源代码是相当容易维护的。
• 一个广泛的标准库：Python 的最大的优势之一是丰富的库，跨平台的，在 UNIX，Windows 和 macOS 兼容很好。
• 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
• 可移植：基于其开放源代码的特性，Python 已经被移植（也就是使其工作）到许多平台。
• 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用 C 或 C++ 完成那部分程序，然后从你的 Python 程序中调用。
• 数据库：Python 提供所有主要的商业数据库的接口。
• GUI 编程：Python 支持 GUI 可以创建和移植到许多系统调用。
• 可嵌入：你可以将 Python 嵌入到 C/C++ 程序，让你的程序的用户获得"脚本化"的能力。
• 面向对象：Python 是强面向对象的语言，程序中任何内容统称为对象，包括数字、字符串、函数等。

02

Python

基础语法

运行 Python

交互式解释器

在命令行窗口执行python后，进入 Python 的交互式解释器。exit() 或 Ctrl + D 组合键退出交互式解释器。

命令行脚本

在命令行窗口执行python script-file.py，以执行 Python 脚本文件。

指定解释器

如果在 Python 脚本文件首行输入#!/usr/bin/env python，那么可以在命令行窗口中执行/path/to/script-file.py以执行该脚本文件。

注：该方法不支持 Windows 环境。

编码

默认情况下，3.x 源码文件都是 UTF-8 编码，字符串都是 Unicode 字符。也可以手动指定文件编码：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;"># -- coding: utf-8 --
</pre>

或者

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;"># encoding: utf-8
</pre>

注意: 该行标注必须位于文件第一行

标识符

• 第一个字符必须是英文字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

注：从 3.x 开始，非 ASCII 标识符也是允许的，但不建议。

保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">>>> import keyword

keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
</pre>

(左右滑动可查看完整代码)

注释

单行注释采用#，多行注释采用'''或"""。

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;"># 这是单行注释
'''
这是多行注释
这是多行注释
'''
"""
这也是多行注释
这也是多行注释
"""
</pre>

行与缩进

Python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。缩进不一致，会导致运行错误。

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠来实现多行语句。

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">total = item_one +
item_two +
item_three
</pre>

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠。

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

等待用户输入

input函数可以实现等待并接收命令行中的用户输入。

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">content = input("

请输入点东西并按 Enter 键
")
print(content)
</pre>

同一行写多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号;分割。

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">import sys; x = 'hello world'; sys.stdout.write(x + '
')
</pre>

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号:结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上end=""或别的非换行符字符串：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">print('123') # 默认换行
print('123', end = "") # 不换行
</pre>

import 与 from...import

在 Python 用 import 或者 from...import 来导入相应的模块。

将整个模块导入，格式为：import module_name

从某个模块中导入某个函数,格式为：from module_name import func1

从某个模块中导入多个函数,格式为：from module_name import func1, func2, func3

将某个模块中的全部函数导入，格式为：from module_name import *

运算符

算术运算符

运算符描述+加-减乘/除%取模*幂//取整除

比较运算符

运算符描述==等于!=不等于>大于<小于>=大于等于<=小于等于

赋值运算符

运算符描述=简单的赋值运算符+=加法赋值运算符-=减法赋值运算符=乘法赋值运算符/=除法赋值运算符%=取模赋值运算符*=幂赋值运算符//=取整除赋值运算符

位运算符

运算符描述&按位与运算符：参与运算的两个值,如果两个相应位都为1，则该位的结果为1，否则为0|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1^按位异或运算符：当两对应的二进位相异时，结果为1_{按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。}x 类似于 -x-1<<左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

逻辑运算符

运算符逻辑表达式描述andx and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值orx or y布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值notnot x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True

成员运算符

运算符描述in如果在指定的序列中找到值返回 True，否则返回 Falsenot in如果在指定的序列中没有找到值返回 True，否则返回 False

身份运算符

运算符描述实例isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 Falseis notis not 是判断两个标识符是不是引用自不同对象x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False

运算符优先级

运算符描述(expressions...), [expressions...], {key: value...}, {expressions...}表示绑定或元组、表示列表、表示字典、表示集合x[index], x[index:index], x(arguments...), x.attribute下标、切片、调用、属性引用*指数 (最高优先级)~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) / % //乘，除，取模和取整除+ -加法减法>> <<右移，左移运算符&位 'AND'^ |位运算符<= < > >=比较运算符<> == !=等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符and or not逻辑运算符if - else条件表达式lambdaLambda 表达式

具有相同优先级的运算符将从左至右的方式依次进行。用小括号()可以改变运算顺序。

变量

变量在使用前必须先"定义"（即赋予变量一个值），否则会报错：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">>>> name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined
</pre>

数据类型

布尔(bool)

只有 True 和 False 两个值，表示真或假。

数字(number)

整型(int)

整数值，可正数亦可复数，无小数。

3.x 整型是没有限制大小的，可以当作 Long 类型使用，所以 3.x 没有 2.x 的 Long 类型。

浮点型(float)

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）

复数(complex)

复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示，复数的实部 a 和虚部 b 都是浮点型。

数字运算

• 不同类型的数字混合运算时会将整数转换为浮点数
• 在不同的机器上浮点运算的结果可能会不一样
• 在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //。
• // 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
• 在交互模式中，最后被输出的表达式结果被赋值给变量 ， 是个只读变量

数学函数

注：以下函数的使用，需先导入 math 包。

函数描述abs(x)返回数字的整型绝对值，如 abs(-10) 返回 10ceil(x)返回数字的上入整数，如 math.ceil(4.1) 返回 5cmp(x, y)如果 x < y 返回 -1，如果 x == y 返回 0，如果 x > y 返回 1。Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。exp(x)返回 e 的 x 次幂(ex)，如 math.exp(1) 返回2.718281828459045fabs(x)返回数字的浮点数绝对值，如 math.fabs(-10) 返回10.0floor(x)返回数字的下舍整数，如 math.floor(4.9) 返回 4log(x)如 math.log(math.e) 返回 1.0，math.log(100,10) 返回 2.0log10(x)返回以 10 为基数的 x 的对数，如 math.log10(100) 返回 2.0max(x1, x2,...)返回给定参数的最大值，参数可以为序列min(x1, x2,...)返回给定参数的最小值，参数可以为序列modf(x)返回 x 的整数部分与小数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示pow(x, y)幂等函数， x**y 运算后的值round(x [,n])返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数sqrt(x)返回数字 x 的平方根

随机数函数

注：以下函数的使用，需先导入 random 包。

函数描述choice(seq)从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数randrange ([start,] stop [,step])从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1random()随机生成下一个实数，它在[0,1)范围内seed([x])改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seedshuffle(lst)将序列的所有元素随机排序uniform(x, y)随机生成下一个实数，它在[x,y]范围内

三角函数

注：以下函数的使用，需先导入 math 包。

函数描述acos(x)返回 x 的反余弦弧度值asin(x)返回 x 的反正弦弧度值atan(x)返回 x 的反正切弧度值atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值cos(x)返回 x 的弧度的余弦值hypot(x, y)返回欧几里德范数 sqrt(xx + yy)sin(x)返回的 x 弧度的正弦值tan(x)返回 x 弧度的正切值degrees(x)将弧度转换为角度，如 degrees(math.pi/2) 返回 90.0radians(x)将角度转换为弧度

数学常量

常量描述pi数学常量 pi（圆周率，一般以π来表示）e数学常量 e，e 即自然常数（自然常数）

字符串(string)

• 单引号和双引号使用完全相同
• 使用三引号('''或""")可以指定一个多行字符串
• 转义符(反斜杠)可以用来转义，使用r可以让反斜杠不发生转义，如r"this is a line with "，则 会显示，并不是换行
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复
• 字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始
• 字符串不能改变
• 没有单独的字符类型，一个字符就是长度为 1 的字符串
• 字符串的截取的语法格式如下：变量[头下标:尾下标]

转义字符

转义字符描述在行尾时，续行符\反斜杠符号'单引号"双引号a响铃退格(Backspace)e转义空 换行�纵向制表符 横向制表符 回车换页oyy八进制数，yy代表字符，例如：o12代表换行\xyy十六进制数，yy代表字符，例如：\x0a代表换行other其它的字符以普通格式输出

字符串运算符

操作符描述实例+字符串连接'Hello' + 'Python' 输出结果：'HelloPython'*重复输出字符串'Hello' * 2 输出结果：'HelloHello'[]通过索引获取字符串中字符'Hello'[1] 输出结果 e[ : ]截取字符串中的一部分'Hello'[1:4] 输出结果 ellin成员运算符，如果字符串中包含给定的字符返回 True'H' in 'Hello' 输出结果 Truenot in成员运算符，如果字符串中不包含给定的字符返回 True'M' not in 'Hello' 输出结果 Truer/R原始字符串，所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法print(r' ') 或 print(R' ')%格式化字符串

字符串格式化

在 Python 中，字符串格式化不是 sprintf 函数，而是用 % 符号。例如：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">print("我叫%s， 今年 %d 岁！" % ('小明', 10))
// 输出:
我叫小明， 今年 10 岁！
</pre>

格式化符号:

符号描述%c格式化字符及其 ASCII 码%s格式化字符串%d格式化整数%u格式化无符号整型%o格式化无符号八进制数%x格式化无符号十六进制数%X格式化无符号十六进制数（大写）%f格式化浮点数字，可指定小数点后的精度%e用科学计数法格式化浮点数%E作用同 %e，用科学计数法格式化浮点数%g%f 和 %e 的简写%G%f 和 %E 的简写%p用十六进制数格式化变量的地址

辅助指令:

指令描述*定义宽度或者小数点精度-用做左对齐+在正数前面显示加号

在正数前面显示空格#在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')0显示的数字前面填充'0'而不是默认的空格%'%%'输出一个单一的'%'(var)映射变量(字典参数)m.n.m 是显示的最小总宽度，n 是小数点后的位数(如果可用的话)

Python 2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

多行字符串

• 用三引号(''' 或 """)包裹字符串内容
• 多行字符串内容支持转义符，用法与单双引号一样
• 三引号包裹的内容，有变量接收或操作即字符串，否则就是多行注释

实例：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">string = '''
print( math.fabs(-10))
print(
random.choice(li))
'''
print(string)
</pre>

输出：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">print( math.fabs(-10))
print(
random.choice(li))
</pre>

Unicode

在 2.x 中，普通字符串是以 8 位 ASCII 码进行存储的，而 Unicode 字符串则存储为 16 位 Unicode 字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在 3.x 中，所有的字符串都是 Unicode 字符串。

字符串函数

方法名描述str.capitalize()首字母大写，其余字符小写str.center(width[, fillchar])返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格str.count(sub, start= 0,end=len(string))统计子字符串在字符串中出现的次数str.encode(encoding='UTF-8',errors='strict')以指定的编码格式编码字符串，返回 bytes 对象bytes.decode(encoding="utf-8", errors="strict")以指定的编码格式解码 bytes 对象，返回字符串str.endswith(suffix[, start[, end]])判断字符串是否以指定后缀结尾str.expandtabs(tabsize=8)把字符串中的 tab 符号( )转为空格str.find(str, beg=0, end=len(string))如果包含子字符串返回开始的索引值，否则返回-1str.index(str, beg=0, end=len(string))如果包含子字符串返回开始的索引值，否则抛出异常str.isalnum()检测字符串是否只由字母和数字组成str.isalpha()检测字符串是否只由字母组成str.isdigit()检测字符串是否只由数字组成str.islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 Falsestr.isupper()检测字符串中所有的字母是否都为大写str.isspace()如果字符串中只包含空格，则返回 True，否则返回 Falsestr.istitle()检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写str.join(sequence)将序列的元素以指定的字符连接生成一个新的字符串len(s)返回对象（字符串、列表、元组等）长度或项目个数str.ljust(width[, fillchar])返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串str.lower()转换字符串中所有大写字符为小写str.upper()转换字符串中所有小写字符为大写str.strip([chars])移除字符串头尾指定的字符（默认为空格）或字符序列str.maketrans(intab, outtab)用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。str.translate(table)根据参数table给出的表转换字符串的字符max(str)返回字符串中最大的字符min(str)返回字符串中最小的字符str.replace(old, new[, max])把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次str.split(str="", num=string.count(str))通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串str.splitlines([keepends])按照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符str.startswith(str, beg=0,end=len(string))检查字符串是否是以指定子字符串开头str.swapcase()对字符串的大小写字母进行互换str.title()返回"标题化"的字符串，即所有单词都是以大写开始，其余字母均为小写str.zfill(width)返回指定长度的字符串，原字符串右对齐，前面填充0str.isdecimal()检查字符串是否只包含十进制字符，只适用于 Unicode 对象

字节(bytes)

在 3.x 中，字符串和二进制数据完全区分开。文本总是 Unicode，由 str 类型表示，二进制数据则由 bytes 类型表示。Python 3 不会以任意隐式的方式混用 str 和 bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。

• bytes 类型与 str 类型，二者的方法仅有 encode() 和 decode() 不同。
• bytes 类型数据需在常规的 str 类型前加个 b 以示区分，例如 b'abc'。
• 只有在需要将 str 编码(encode)成 bytes 的时候，比如：通过网络传输数据；或者需要将 bytes 解码(decode)成 str 的时候，我们才会关注 str 和 bytes 的区别。

bytes 转 str：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">b'abc'.decode()
str(b'abc')
str(b'abc', encoding='utf-8')
</pre>

str 转 bytes：

<pre style="-webkit-tap-highlight-color: transparent; box-sizing: border-box; font-family: Consolas, Menlo, Courier, monospace; font-size: 16px; white-space: pre-wrap; position: relative; line-height: 1.5; color: rgb(153, 153, 153); margin: 1em 0px; padding: 12px 10px; background: rgb(244, 245, 246); border: 1px solid rgb(232, 232, 232); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">'中国'.encode()
bytes('中国', encoding='utf-8')
</pre>

基础语法完结

1.调用函数：

1.1 函数名是指向一个函数对象的引用：

把函数名赋给一个变量，相当于给这个函数起了一个“别名”：

a = abs # 变量a指向abs函数

a(-1) # 所以也可以通过a调用abs函数1

1.2 错误信息：

• 传入参数个数不对， 报TypeError，比如：

TypeError: abs() takes exactly one argument (2 given)

• 传入参数类型不对，也是TypeError，比如：

TypeError: bad operand type for abs(): str

2.定义函数

2.1 定义函数

• 格式：

def my_abs(x):

if x >= 0:

return x

else:

return -x

• 定义函数时，需要确定函数名和参数个数
• 如果有必要，可以先对参数的数据类型做检查。数据类型检查可以用内置函数isinstance()实现，比如：

def my_abs(x):

if not isinstance(x, (int, float)):

raise TypeError(bad operand type)

if x >= 0:

return x

else:

return -x

2.2 return：

• 如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
• return None可以简写为return。
• 返回多个值 比如：return nx, ny

Python的函数返回多值其实就是返回一个tuple，在语法上，返回一个tuple可以省略括号

2.3 导入函数：

用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）

2.4 pass：

• 空函数

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():

pass

实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

• pass用在其它地方：

if age >= 18:

pass

缺少了pass，代码运行就会有语法错误。

3.函数的参数

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。

3.1 位置参数

就是普通的参数，比如power(x)，这个x就是位置参数

3.2 默认参数

(1): 表示

enroll(name, gender, age=6, city=Beijing)

(2): 作用：

• 比如我们之前定义了，一个power(x) 函数计算x平方，之后把这个函数修改为power(x,n)来计算x的n次方。 不过此时旧的代码power(5)就会调用失败，因为缺少了一个参数。所以我们引入默认参数，这样旧的代码也可以正常运行。

def power(x, n=2):

• 比如我们写个一年级小学生注册的函数，需要传入name和gender两个参数enroll(name, gender)，如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。这时候我们可以把年龄和城市设为默认参数，只有与默认参数不符的学生才需要提供额外的信息。

enroll(name, gender, age=6, city=Beijing)

默认参数降低了函数调用的难度，而一旦需要更复杂的调用时，又可以传递更多的参数来实现。无论是简单调用还是复杂调用，函数只需要定义一个

(3): 多个默认参数：

• 按顺序提供默认参数，这时候不需要加上参数名，比如：

调用enroll(Bob, M, 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上

• 不按顺序提供部分默认参数时，需要把参数名写上，比如：

enroll(Adam, M, city=Tianjin

(4):默认参数的坑：

• 默认参数必须指向不变的对象

我们举个例子说明：

比如定义一个函数如下

def add_end(L=[]):

L.append(END)

return L

第一次调用

add_end()

[END]

第二次调用

add_end()

[END, END]

第三次调用

add_end()

[END, END, END]

我们发现默认参数是[]，但是函数似乎每次都“记住了”上次添加了END后的list，这是因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

解决办法：

用None这个不变对象来替代[] list这个可变的对象：

def add_end(L=None):

if L is None:

L = []

L.append(END)

return L

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。

3.3可变参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

(1): 表示 （在参数前面加一个*号）

calc(*numbers)

(2):作用：

当不确定参数个数的时候，

我们以数学题为例子，给定一组数字a，b，c……，请计算a2 + b2 + c2 + ……。此时参数个数不确定。

(3):可变参数传入的是一个tuple

如果不用可变参数，则调用的格式如下：

calc((1, 3, 5, 7))

用了可变参数则调用的可以简化如下：

calc(1, 2, 3)

(4):如果已经有一个list或者tuple，要调用一个可变参数，则可以把list或tuple的元素变成可变参数传进去。

nums = [1, 2, 3]

calc(*nums)

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

3.4 关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

(1): 表示 （在参数前面加两个*号）

person(name, age, **kw)

(2): 调用

person(Bob, 35, city=Beijing)

name: Bob age: 35 other: {city: Beijing}

person(Adam, 45, gender=M, job=Engineer)

name: Adam age: 45 other: {gender: M, job: Engineer}

(3): 作用

试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

def person(name, age, **kw):

print(name:, name, age:, age, other:, kw)

extra = {city: Beijing, job: Engineer}

person(Jack, 24, **extra)

name: Jack age: 24 other: {city: Beijing, job: Engineer}

(4): 如果已经有一个dict，可以直接把dict作为关键字参数传进去。

person(Jack, 24, **extra)

extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({a: 1, b: 2})。

3.5 命名关键字参数

(1): 作用：

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数，如果要限制关键字参数的名字，就可以用命名关键字参数。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

(2): 表示

• 需要一个特殊分隔符，后面的参数被视为命名关键字参数。

person(name, age, *, city, job)

• 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

person(name, age, *args, city, job)

(3): 调用

• 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错 （因为它会把所有的都当作位置参数，就会超过位置参数的个数，报TypeEerror错误。）

def person(name, age, *, city, job):

print(name, age, city, job)

person(Jack, 24, city=Beijing, job=Engineer)

Jack 24 Beijing Engineer

• 命名关键字参数，每个参数如果没有默认值都必须输入，否则报错

person(Jack, 24, city=Beijing)

Traceback (most recent call last):

File <stdin>, line 1, in <module>

TypeError: person() missing 1 required keyword-only argument: job

• 命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city=Beijing, job):

print(name, age, city, job)

3.6 参数组合

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

使用args和*kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

3.7 各个参数的总结

python基础语法与函数总结

4.递归函数

4.1 定义

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

4.2 例子

def fact(n):

if n==1:

return 1

return n * fact(n - 1)

4.3 优点

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

4.4 注意

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

解决办法：

通过尾递归优化，尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。

def fact(n):

return fact_iter(n, 1)

def fact_iter(num, product):

if num == 1:

return product

return fact_iter(num - 1, num * product)

num - 1和num * product在函数调用前就会被计算，不影响函数调用。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。