Living Slowly - 热爱技术，热爱生活 - 知识归纳

Living out of the way you want.

0%

Python-基础知识

> > 阅读次数： 字数： 6.7k 时长 ≈ 6 分钟

重新复习 Python 知识，精简之前的笔记。

基础语法

编码

默认情况下，python3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。

ASCII 编码和 Unicode 编码的区别：

  • ASCII 编码是 1 个字节，Unicode 编码是 2 个字节
  • 字母 A 用 ASCII 编码十进制是 65，二进制是 01000001
  • 字母 O 用 ASCII 编码十进制是 48，二进制是 00110000
  • 汉字‘中’已经超出了 ASCII 编码的范围，用 Unicode 编码十进制是 20013，二进制 01001110 001011101
  • Unicode 可变长编码‘UTF-8’。UTF-8 编码把一个 Unicode 字符根据不同的数字大小编码成 1-6 个字节，常用的英文字母被编码成 1 个字节， 汉字通常是 3 个字节，生僻的字符会被编码成 4-6 个字节。

对于单个字符的编码，python 提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。

标识符

  • 第一个字符必须是字母或下划线
  • 标识符的其他部分由字母/数字/下划线组成
  • 标识符对大小有区分

保留字

保留字即 关键字

1
2
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']

注释

  • 单行以 # 开头
  • 三引号（单双引号）

行间缩进

Python 最具特色的就是使用缩进来表示代码块。同一个代码块使用同样的缩进空格数。

多行语句

语句长度过长可使用反斜杠来实现多行语句。也可使用[],{}和()来代替反斜杠。

数据类型

整数/长整数/浮点数和复数

  • 整数： 1
  • 长整数：比较大的整数
  • 浮点数： 1.23 3E-2
  • 复数：1+2j

空行

函数之间或类的方法之间用空行分隔；PEP8 要求函数空一行，类空两行，类的方法之间空一行，这表示一段新的代码。

空行域代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会报错。

空行也是程序代码的一部分

字符串

  • 单引号和双引号使用完全相同
  • 使用三引号（’’’或”””）可以制定一个多行字符串
  • 转义符’\’
  • 自然字符串，通过字符串前加 r、R。
  • 允许处理 unicode 字符串，加前缀 u、U，如 u"this is an unicode string"
  • 字符串是 不可变 的

输入

同一行显示多条语句；语句之间可以使用分号分隔。

多个语句构成代码块

缩进相同的语句构成一个代码块，也称之为代码组

if/while/def 和 class 这样的复合语句，首行以关键字开始，以冒号:结束

1
2
3
4
5
6
if expression:
    suite
elif expression:
    suite
else:
    suite

输出

print 默认输出时换行，如果要实现不换行需要在变量末尾加上 end=""

1
2
3
4
5
6
7
8
x="a"
y="b"
# 换行输出
print(x)
print(y)
# 不换行输出
print( x, end=" " )
print( y, end=" " )

import 与 from import

导入需要的模块

1
2
3
4
5
6
7
8
# 整个模块导入
import somemodule
# 从某个模块中导入如指定函数
from somemodule import somefunction
# 从某个模块中导入多个函数
from somemodule import firstfunc,secondfunc,thirdfunc
# 从某个模块中导入全部函数（不建议使用，避免函数覆盖）
from somemodule import *

命令行参数

很多程序可以添加可选参数获取相应的信息，python 可使用 ­h 参数查看各参数帮助信息；也可以使用 help() 函数来显示信息,使用 q 退出说明 文档，如果仅仅想得到文档字符串: print(max.__doc__)

基本数据类型

Python 中变量不需要声明。但变量在使用前需要赋值，变量赋值以后该变量才会被创建。变量没有类型，所以 类型 是变量所指的内存中对象的类型。

等号 ‘=’ 用来给变量赋值;等号左边是一个变量名，右边是存储在变量中的值

多个变量赋值

1
2
a = b = 1
a, b = 1, 2

标准数据类型

Python3 中有六种标准的数据类型

  • Number
  • String
  • List
  • Tuple
  • Dictionary

Number

python3 支持 int/float/bool/complex

  • 只有一种整数类型 int，表示长整型。

  • 内置的 type() 函数可以用来查询变量所指的对象类型。

  • 可以用 isinstance 来判断 isinstance 和 type 的区别：

    • type() 不会认为子类是一种父类类型。
    • isinstance() 会认为子类是一种父类类型。

  • 数值运算

    1
    2
    3
    17 / 4  # 整除
    17 // 4 # 
    17 % 3  # 取余

String（字符串）

  • 字符串使用单双引号，可以使用反斜杠 转义 特殊字符

  • 字符符串的截取的语法格式如下：
    变量[头下标:尾下标]
    索引值以 0 为开始值，­1 为末尾的开始位置。

  • 加号（+）是字符串的连接符，星号（*）表示复制当前字符串，紧跟的数字为复制的次数。

    1
    2
    3
    4
    5
    6
    str = 'runobb'
    print(str)  # 输出字符串
    print(str[0:‐1])  # 输出第一个到倒数第二个的所有字符
    print(str[0])  # 输出字符串第一个字符
    print(str[2:5])  # 输出从第三个开始到第五个的字符
    print(str[2:])  # 输出从第三个开始的后的所有字符

  • 反斜杠转义特殊字符，如果不需要让反斜杠被转义，可以在字符串前面加个 r，表示原始字符串。

    1
    2
    print('Ru\noob')
    print(r'Ru\noob')

    另外反斜杠可以作为续行符，也可以使用’‘’…‘’'或"“”…“”"跨越多行。 Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

与 C 字符串不同的是，Python 不能被改变，向一个索引位置赋值，比如 word[0]=‘m’ 会导致错误。

注意：

  • 反斜杠可以用来转义，使用 r 可让反斜杠不发生转义。
  • 字符串可以用’+'运算符连接在一起，在 * 运算符重复。
  • python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 ­1 开始
  • python 中的字符串不能改变

LIST（列表）

  • list（列表）是 Python 中使用最频繁的数据类型。

  • 列表中可完成大多数集合类的数据结构实现。列表中对象的类型可以不同，它支持数字，字符串甚至可以包含列表（所谓的嵌套）。

  • 列表是写在方括号 ‘[]’ 之间，用逗号分隔开的列表。

  • 和字符串一样，列表同样可以被索引和截取，列表截取后返回一个包含所需对象的新列表。

    1
    2
    3
    4
    5
    6
    7
    8
    list = ['abcd', 786 , 2.23, 'runobb', 70.2]
    tinylist =[123, 'runobb']
    print(list)  # 输出完整列表
    print(list[0])  # 输出列表第一个对象
    print(list[1:3])  # 输出第二个开始输出到第三个对象
    print(list[2:])  # 输出从第三个对象开始的所有对象
    print(tinylist * 2)  # 输出两次列表
    print(list + tinylist)  # 连接列表

与 Python 字符串不一样的是，列表中的对象是可以改变的。

list 内置了很多方法，如 append(),pop() 等

注意：

  • list写在方括号之间，对象用逗号隔开
  • 和字符串一样，list可以被索引和切片
  • list可使用+操作符进行拼连
  • list中的对象是可以改变的

Tuple（元组）

元组与列表类似，不同之处在于元组的对象不能修改。元组写在小括号’()'里，对象之间用逗号隔开。

元组中的对象类型也可以不同。

1
2
3
4
5
6
7
8
tuple = ['abcd', 786 , 2.23, 'runobb', 70.2]
tinytuple =[123, 'runobb']
print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组第一个对象
print(tuple[1:3])  # 输出第二个开始输出到第三个对象
print(tuple[2:])  # 输出从第三个对象开始的所有对象
print(tinytuple * 2)  # 输出两次元组
print(tuple + tinytuple)  # 连接元组

元组与字符串类似，可以被索引且下标索引从 0 开始，­1 为从末尾开始的位置。也可以进行截取。其实，可以把字符串看做一种特殊的元组。

虽然 tuple 的对象不可以被修改，但可以包含可变的对象，比如 list 列表。构造包含 0 个或 1 个对象的元组比较特殊，所以有一些额外的语法规则：

1
2
tup1 = ()  # 空元组
tup2 = (20,)  # 一个对象，需要在对象后添加逗号

string、list 和 tuple 都属于 sequence（序列）

注意：

  • 与字符串一样，元组的对象不能修改
  • 元组可以被索引和切片，方法一样
  • 注意构造包含 0 或 1 个对象的元组的特殊语法规则
  • 元组也可以使用 + 操作符进行连接

Set（集合）

集合（set）是一个无序不重复对象的序列。

基本功能是进行成员关系测试和删除重复对象。

可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {}，因为大括号用来创建一个空字典。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
student = {'Tom','Jim','Mary','Tom','Jack','Rose'}
print(student)  # 输出集合，重复的对象自动去掉
# 成员测试
if ('Rose' in student):
    print('Rose在集合中')
else:
    print('Rose不在集合中')

# set 可以进行集合运算
a = set('abracabads')
b = set('alacazam')
print(a)
print(b)
print('====================')
print(a ‐ b)  # a和b的差集
print(a | b)  # a和b的并集
print(a & b)  # a和b的交集
print(a ^ b)  # a和b中不同时存在的对象

Dictionary（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：

  • 字典当中的对象是通过键来存取的，而不是通过偏移存取。
  • 字典是一种映射类型，字典用“{}”标识，它是一个无序的键（key）：值（value)对集合。键（key）必须使用不可变类型。在同一个字典中，键（key） 必须是唯一的。
1
2
3
4
5
6
7
8
9
dict = {}
dict['one'] = "1 ‐自学教程"
dict[2] = "2 ‐自学工具"
tinydict = {'name':'runobb','code':1,'stie':'www.runobb.com'}
print(dict['one'])  # 输出键为'one'的值
print(dict[2])  # 输出键为2的值
print(tinydict)  # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())  # 输出所有值

构造函数 dict() 可以直接从键值对序列中构建字典，示例如下：

1
2
3
dict([('Runobb',1),('Google',2),('Taobao',3)])
{x: x**2 for x in (2,4,6)}
dict(Runobb=1,Google=2,Taobao=3)

另外，字典类型也有一些内置的函数，例如 clear(),keys(),values() 等

注意：

  • 字典是一种映射类型，它的对象是键值对
  • 字典的关键字必须为不可变类型，且不能重复
  • 创建空字典使用{}

数据类型转换

有时候，需要对数据内置的类型进行转换，数据类型的转换，只需要将数据类型作为函数名即可。

函数 描述
int(x[,base]) 将对象 x 转换成一个整数
float(x) 将对象 x 转换成一个浮点数
complex(real[,imag]) 创建一个复数
str(x) 将对象 x 转换成字符串
repr(x) 将对象 x 转换成表达式字符串
eval(str) 用来计算在字符串中的有效 python 表达式，并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列(key,value)元组
frozenset(s) 转换为不可变集合
chr(x) 将对象 x 转换为字符串
ord(x) 将单字符 x 转换为整数值
oct(x) 将整数对象 x 转换为八进制字符串

运算符

什么是运算符？

  • 算数运算符
  • 比较（关系）运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级

算术运算符

以下假设变量 a=10, b=21

运算符 描述 实例
+ 加 a + b 结果为 31
- 减 a - b 结果为 -11
* 乘 a * b 结果为 210
/ 除 a / b 结果为 2.1
% 取余 b % a 结果为 1
** 幂 a ** b 结果为 10 的 21 次方
// 整除 9 // 2 结果为4 9.0 // 2.0 结果为 4.0

比较运算符

假设变量 a=1, b=2

运算符 描述 实例
== 等于 (a == b) 返回 False
!= 不等于 (a != b) 返回 True
> 大于 (a > b) 返回 False
< 小于 (a < b) 返回 True
>= 大于等于 (a >= b) 返回 False
<= 小于等于 (a <= b) 返回 True

赋值运算符

假设变量 a=10,b=20:

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
­= 减法赋值运算符 c ­= a等效于c = c ­ a
/= 除法赋值运算符 c /= a等效于c = c / a
*= 乘法赋值运算符 c *= a等效于c = c * a
%= 取余赋值运算符 c %= a等效于c = c % a
**= 幂赋值运算符 c **= a等效于c = c ** a
//= 整除赋值运算符 c // a等效于c = c // a

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算符法则如下：变量 a=60,b=13

运算符 描述 实例
& 按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0。 (a & b)输出结果为 12，二进制解释： 0000 1100
| 按位或运算符：参与运算的两个值，如果有一个相应位为1，则该位的结果为1，否则为0。 (a | b)输出结果 61，二进制解释：0011 1101
& 按位运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0。 (a & b)输出结果为12，二进制解释： 0000 1100
^ 按位异或运算符：当两对应的二进位相异时，结果为1. (a ^ b)输出结果为49，二进制解释：0011 0001
~ 按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1,。~x类似于 ­x­1 (~a)输出结果为­61，二进制解释：在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0. a << 2输出结果为240，二进制解释：1111 0000
>> 右移运算符：把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数 a >> 2 输出结果为 15，二进制解释：0000 1111

逻辑运算符

Python语言支持逻辑运算符，假设变量 a=10,b=20

运算符 逻辑表达式 描述 实例
and x and y 布尔“与”，如果 x 为 False，x and y 反回False，否则返回 y 的计算值 (a and b) 返回20
or x or y 布尔“与”，如果 x 为 False，x and y 反回False，否则返回 y 的计算值 (a or b) 返回10
not not x 布尔“非”，如果x是True，返回 False，如果 x 为 False，返回 True not(a and b ) 返回 False

成员运算符

包括字符串、列表或元组

运算符 描述 实例
in 如果在指定的序列中找到值返回为True，否则返回False x 在 y 序列中，如果 x 在 y 序列中返回 True
not in 如果不在指定的序列中找到值返回为True，否则返回False x 不在 y 序列中，如果 x 不在 y 序列中返回 True

身份运算符

身份运算符用于比较两个对象的存储单元

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

id() 函数用于获取对象内存地址

is 与 == 的区别：

is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符 描述
** 指数（最高优先级）
~ + ­ 按位翻转，一元加号和减号（最后两个的方法名为+@和­@
* / % // 乘，除，取余，整除
+ ­ 加法减法
>> << 右移，左移运算符
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= ­= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

字符串

字符串是python中最常用的数据类型。可以使用引号（'或")来创建字符串。创建字符串，只要为变量分配一个值就行。

访问字符串中的值

Python 不支持单字符类型，单字符也在 Python 作为一个字符串使用。 Python 访问子字符串，可以使用方括号来截取字符串。

1
2
3
var1 = "Hello world"
var1[0]
var1[0:3]

字符串更新

可以将截取的字符串与其他字段拼接

1
2
var1 = "Hello world"
print("已更新字符串", var1[:6] + "Test")

转义字符

python 用反斜杠（\）转义字符

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

字符串运算符

假设变量 a = 'Hello', b = 'Python'

操作符 描述 实例
+ 字符串连接 a + b 输出结果： HelloPython
* 重复字符串 a * 2 输出结果： HelloHello
[] 通过索引获取字符串中的字符 a[1] 输出结果： e
[:] 截取字符串中的部分 a[1:4] 输出结果： ell
in 成员运算符，如果字符串中包含给定的字符返回 True，否则返回 False ('H' in a) 输出结果： True
not in 成员运算符，如果字符串中不包含给定的字符返回 True，否则返回 False ('C' no in a) 输出结果: True
r/R 原始字符串--所有的字符串都是直接按照字面的意思使用，没有转义特殊或不能打印的字符。原始字符串处在字符串的第一个引号前加上字母 r 或 R 以外，与普通字符串有着几乎完全相同的用法 print(r'\n') print(R'\n') 输出结果为： \n
% 格式字符串

字符串格式化

Python 支持格式化字符串的输出。最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

Python2.6 开始，可以使用字符串的 format() 方法，会用传入的参数依次替换字符串内的占位符{0}、{1}。。。，不过比%麻烦很多

示例：

1
2
print("My name is %s ,my age is %d." % ('Ming',10))
# 输出结果为：My name is Ming ,my age is 10.

Python3.6 开始可以使用 f 来格式化

1
2
3
4
5
# 示例
a = 'Hello'
b = 'World'
print(f"{a} {b}")
# 输出结果: Hello World
符号 描述
%% 表示 % 字符
%c 格式化字符及其 ASCII 码
%s 格式化字符串
%d 格式化证书
%u 格式化无符号整数
%o 格式化无符号八进制
%x 格式化无符号十六进制
%X 格式化无符号十六进制（大写）
%f 格式化浮点数字，可以指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同 %e
%g %f 和 %e 的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

格式化操作符辅助指令

符号 功能
* 定义宽度或者小数点精度
- 左对齐
+ 在正数前面显示加号（+）
< sp> 在正数前面显示空格
# 在八进制数前面显示零（‘0’），在十六进制前面显示‘0x’或者‘0X’（取决于用的是'x' 还是‘X’）
0 显示的数字前面填充‘0’而不是默认的空格
% ‘%%’ 输出一个单一的 %
(var) 映射变量（字典参数）
m.n. m 是显示的最小宽度，n 是小数点后的位数

三引号

允许一个字符串跨多行，字符串可以包含换行符、制表符和其他特殊字符。

1
2
3
4
5
6
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)

三引号可以从引号和特殊字符串的分离出来。当需要一块 HTML 或 SQL 时，用字符串组合，特殊字符串转义将会非常的繁琐。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''

cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')

Unicode 字符串

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

字符串内建函数

序号 用法 描述
1 'str'.capitalize() 将字符串的第一个字符转换为大写
2 str.center(width，fillchar) 返回一个指定长度（width）源字符串居中的字符串，fillchar 为填充的字符，默认为空格。
3 str.count(str) 返回 str 在字符串中出现的次数
4 bytes.decode(encoding='utf­8', errors='strict') python3 中没有 decode 方法，可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回
5 encode(encoding='UTF­8', errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 ‘ignore’ 或者 ‘replace’
6 str.endswith(suffix) 检查字符串是否以 suffix 结束，如果是返回 True，否则返回 False
7 str.expandtabs(tabsize=8) 把字符串中的 tab 符号转为空格，tab 符号默认的空格数量是 8
8 str.find(info) 检测 info 是否包含在字符串中，如果包含返回开始的索引值，否则返回 ­1
9 str.index(info) 跟 find() 方法一样，只不过如果 info 不在字符串中会报一个异常
10 str.isalnum() 如果字符串非空并且所有字符都是字母或是数字则返回 True，否则返回 False
11 str.isalpha() 如果字符串非空并且所有字符都是字母则返回 True，否则返回False
12 str.isdiqit() 如果字符串只包含数字则返回 True，否则返回 False
13 str.islower() 如果字符串中所有字符都是小写，则返回 True，否则返回 False
14 str.isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15 str.isspace() 如果字符串中只包含空白，则返回 True，否则返回 False
16 str.istitle() 如果字符串是标题(见title)则返回 True，否则返回 False
17 str.isupper() 如果字符串中所有字符都是大写，则返回 True，否则返回 False
18 str.join(seq) 以指定字符串作为分隔符，将 seq 中所有的对象(的字符串表示)合并为一个新的字符串
19 len(str) 返回字符串长度
20 str.ljust(width[, fillchar]) 返回一个元字符串左对齐，并使用 fillchar 填充至 width 的新字符串，fillchar 默认为空格。
21 str.lower() 转换字符串中所有大写字符为小写。
22 str.lstrip() 截掉字符串左边的空格或指定字符
23 str.maketrans(x, y, z) 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要红钻换的字符，第二个参数也是字符串表示转换的 目标
24 max(str) 返回字符串 str 中值最大的字母
25 min(str) 返回字符串 str 中值最小的字母
26 str.replace(old, new[, max]) 将字符串中 old 替换成 new，如果 max 指定，则替换不超过 max 次数。
27 str.rfing(str, beg=0, end=len(string)) 类似于 find() 函数，不过是从右边开始查找
28 str.rindex(str, beg=0, end=len(string)) 类似于 index(),不过是从右边开始
29 str.rstrip() 删除字符串字符串末尾的空格
30 str.rjust()idth, fillchar) 返回一个元字符串右对齐并使用 fillchar （默认为空格）填充至长度 width 的新字符串
31 str.split(str='', num=string,.conut(str)) num=string.cont(str)以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个字符串
32 str.splitlines([keepends]) 按照行()\r','\r\n','\n'）分割，返回一个包含各行作为对象的列表，如果参数 keepends 为 False，不包含换行符，如果为 True， 则保留换行符
33 str.startswith(str) 检查字符串是否以 str 开头，则返回 True，否则返回 False。
34 str.strip([charsh]) 在字符串上执行 lstrip() 和 rstrip()
35 str.swapcase() 将字符串中大写转换为小写，小写转换为大写
36 str.title() 返回‘标题化’的字符串，就是说所有单词都是以大写开始，其余字母均为小写。
37 str.translate(table ,deletechars='') 根据 table 给出的表（含256个字符）转换 string 的字符，要过滤掉的字符放到 deletechars 参数中
38 str.upper() 转换字符串中的小写字母为大写
39 str.zfill(width) 返回长度为 width 的字符串，原字符串右对齐，前面填充 0
40 str.isdeciml() 检查字符串是否只包含十进制字符，如果是返回 True，否则返回 False

数字

Python数字数据类型用于存储数值。

数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。

1
2
num1 = 1
num2 = 10

可以通过del语句删除一些数字对象的引用。 del语句的语法是：

1
del num1[, num2, [num3, [..., numn]]]

也可以通过使用del语句删除单个或多个对象的引用

1
2
del num1
del num2, num3

Python支持三种不同的数据类型：

  • 整型(int)­­通常被称为整型或整数，是正或负整数，不带小数点。python3 整型是没有限制大小的，可以当做 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
  • 浮点型（float）­­浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法标识(2.5e2 = 2.5 * 10**2 = 250)
  • 复数（complex）­­复数由实数部分和虚数部分构成，可以用 a+bj ，或者 complex(a,b) 标识，复数的实部和虚部都是浮点型。
    可以使用十六进制和八进制来代表整数
1
2
num1 = 0xA0F  # num1 输出结果为： 2575
num2 = 0o37  # num2 输出结果为： 31

数字类型转换

对数据内置的类型进行转换，需要将数据类型作为函数名即可。

  • int(x)- -将 x 转换为一个整数。
  • float(x)- -将 x 转换到一个浮点数
  • complex(x)- -将 x 转换到一个复数，实数部分为 x，虚数部分为 0.
  • complex(x,y)- -将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。
1
2
num1 = 1.0
int(num1)  # 将浮点数 1.0 转换为整数 1

数字运算

Python 解释器可以当做一个简单的计算器，可以在解释器输入一个表达式，它将输出表达式的值。 表达式的语法很直白：+ ­ * / 和其他语言（如 pascal 或 C）里一样

1
2
3
4
5
6
7
8
9
10
11
12
>>> 2 + 2
4
>>> 50 ‐ 5 * 6
20
>>> ( 50 ‐ 5 * 6 ) / 4
5.0
>>> 8 / 5 #总是返回一个浮点数
1.6
>>> 8 // 5
1
>>> 9 % 4
1

注意：

  • 在不同的机器上浮点运算的结果可能会不一样。
  • 在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符//。
  • 变量在使用前必须先“定义”（即赋值）
  • 不同类型的数字混合运算时会将整数转换为浮点数
1
2
3
4
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 /2
3.5

在交互模式下，最后被输出的表达式结果被赋值给变量 _，此处 _ 变量应被用户视为只读变量。

1
2
3
4
5
6
7
8
>>> tar = 12.5 /100
>>> price = 100.50
>>> price * tar
12.5625
>>> price + _
113.0625
>>> round(_,2)
113.06

数字内建函数

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

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

需要导入 random 类

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

三角函数

函数 描述

数学常量

常量 描述
math.pi 圆周率，π 表示
math.e 自然常数

列表

序列是 python 中最基本的数据结构。序列中的每个对象都分配一个数字- -它的位置或索引，第一个索引是 0，第二个索引是 1，依次类推。

  • Python 有 6 个序列的内置类型，但最常见的是 列表 和 元组 。
  • 列表中每个数据项都有一个与之关联的数值偏移量。
  • 序列都可以进行的操作包括索引、切片、加、乘、检查成员，列表索引是从 0 开始的。
  • 此外，python已经内置确定序列的长度及确定最大和最小的对象的方法。
  • 列表是最常用的python数据类型，可以作为一个方括号内的逗号分割值出现。
  • 列表的数据项不需要具有相同的类型
  • 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
1
2
list1 = [ 'Google','Runobb',1997,222]
list2 = [1,23,2,45,6,7]

访问列表中的对象

使用下标索引来访问列表中的值，同样可以使用方阔好 [:] 的形式截取对象

1
2
3
4
5
6
7
8
list1 = [ 'Google','Runobb',1997,222]
list2 = [1,23,2,45,6,7]
print("list1[0]:",list1[0])  # 输出结果为： list1[0]: Google
print("list2[1:5]",list2[1:5])  # 输出结果为： list2[1:5] [23, 2, 45, 6]

movies = ["test", 1, "test1", 2, ["test3",["test4",3]]]
# 获取movies列表中第4个对象["test3", ["test4",3]]中下标为1的对象["test4", 3]中的下标为 1 的对象，即 3
print(movies[4][1][1])  # 输出结果为： 3

删除列表中的对象

可以使用del语句来删除列表的对象

1
2
3
4
5
6
7
list1 = [ 'Google','Runobb',1997,222]
print(list1)  # 输出结果为： ['Google', 'Runobb', 1997, 222]
del list1[2]
print("删除第三个对象为",list1)  # 输出结果为： 删除第三个对象为 ['Google', 'Runobb', 222]
list1.pop() # 删除最后一个对象
list1.pop(i) # 删除 i 索引位置的对象
list1.remove("test") # 删除test对象

列表操作符

列表对 + 和 * 的操作符与字符串相似，+ 号用于组合列表，* 号用于重复列表

表达式 结果 描述
len([1,2,3]) 3 列表长度
[1,2,3] + [4,5,6] [1,2,3,4,5,6] 组合列表
['Hi'] * 4 ['Hi''Hi''Hi''Hi'] 重复列表
3 in [1,2,3] True 对象是否存在于列表中
for x in [1,2,3]:print(x,end="") 1 2 3 迭代列表

列表截取与拼接

截取操作：

1
2
3
4
5
6
7
>>> L = ['Google','Runobb','Taobao']
>>> L[2]
'Taobao'
>>> L[‐2]
'Runobb'
>>> L[1:]
['Runobb', 'Taobao']

拼接操作：

1
2
3
>>> a = [1,2,3,5,6]
>>> a + [123,123,123,1241111,22]
[1, 2, 3, 5, 6, 123, 123, 123, 1241111, 22]

嵌套列表

使用嵌套列表即在列表里创建其他列表

1
2
3
4
5
6
7
8
9
>>> a = ['a','v','s']
>>> n = [1,2,3]
>>> x = [ a,n ]
>>> x
[['a', 'v', 's'], [1, 2, 3]]
>>> x[0]
['a', 'v', 's']
>>> x[0][1]
'v'

列表函数与方法

  • 函数
序号 表达式 描述
1 len(list) 列表个数
2 max(list) 列表中的最大值
3 min(list) 列表中的最小值
4 list(seq) 将对象转换为列表
  • 方法
序号 表达式 描述
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个对象在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 list.pop(obj=list[­1]) 将移除列表中的一个对象（默认最后一个对象），并且返回该对象的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中对象
9 list.sort([func]) 对原列表进行排序
10 list.clear() 清空列表
11 list.copy() 复制列表

元组

元组与列表类似，不同之处在于元组的对象不能修改。

元组使用小括号，列表使用方括号

元组创建很简单，只需要在括号中添加对象，并使用逗号隔开即可。

1
2
3
tup1 = ('Google','Runobb','1997','200')
tup2 = (1,2,3,4,5)
tup3 = "a","b","c","d"
  • 创建空元组
1
tup1 = ()

元组中包含一个对象时，需要在对象后面添加 逗号，否则括号会被当作运算符使用：

1
2
3
4
5
6
>>> tup1 = (50)
>>> type(tup1) # 不插入，为整数型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 插入，为元组
<class 'tuple'>

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值

1
2
3
4
5
6
tup1 = ('Google','Runobb','1997','200')
tup2 = (1,2,3,4,5)
tup3 = "a","b","c","d"

print("tup1[0]:",tup1[0])  # 输出结果为： tup1[0]: Google
print("tup2[1:5]:",tup2[1:5])  # 输出结果为： tup2[1:5]: (2, 3, 4, 5)

修改元组

元组中的对象是不允许修改的，但我们可以对元组进行拼接组合

1
2
3
4
5
6
7
tup1 = ('Google','Runobb','1997','200')
tup2 = (1,2,3,4,5)
# 以下修改元祖对象操作是非法的
# tup[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)  # 输出结果为： ('Google', 'Runobb', '1997', '200', 1, 2, 3, 4, 5)

删除元组

元组中的对象是不允许删除的，但可以使用del语句删除整个元组。

1
2
3
4
5
tup1 = ('Google','Runobb','1997','200')
print(tup1)  # 输出结果为： ('Google', 'Runobb', '1997', '200')
del tup1
print("删除后的元组tup1:")  
print(tup1)  # 会报错

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算

表达式 结果 描述
len((1, 2, 3)) 3 计算对象个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
('Hi',) * 4 ('Hi', 'Hi', 'Hi', 'Hi',) 复制
3 in (1, 2, 3) True 对象是否存在
for x in (1, 2, 3):print(x) 1 2 3 迭代

元组的索引和截取

因为元组也是一个序列，可以访问元组中的指定位置的对象，也可以截取索引中的对象。

1
2
3
4
5
6
7
>>> L = ('Google','Runobb','Taobao')
>>> L(2)
'Taobao'
>>> L(‐2)
'Runobb'
>>> L(1:)
('Runobb', 'Taobao')

元组的内置函数

1
2
3
4
5
6
7
8
9
10
11
12
>>> tuple = ('Google', 'Runobb', 'Taobao')
>>> len(tuple) #计算元组元素个数
3
>>> tuple = ('5', '4', '8')
>>> max(tuple) #返回元组中元素最大值
'8'
>>> min(tuple) #返回元组中元素最小值
'4'
>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1 = tuple(list) #将列表转换为元组
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

字典

字典是一种可变容器模型，且可存储任意类型对象。

字典的每个键值（key=>value）对用冒号(：)分隔，每个对之间用逗号(，)分隔，整个字典包括在或括号 ‘{}’ 中

1
d = {key1 : value1, key2 : value2}

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

1
dict = {'Alie' : '23', 'Beth' : '9012', 'Celi' : '123'}

访问字典里的值

访问的键必须在字典里

1
2
3
4
5
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> print("dict['Name']: ", dict['Name'])
dict['Name']: Runoob
>>> print("dict['Age']: ", dict['Age'])
dict['Age']: 7

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

1
2
3
4
5
6
7
8
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict['Age'] = 8; # 更新 Age
>>> dict['School'] = "菜鸟教程" # 添加信息
>>> print("dict['Age']: ", dict['Age'])
dict['Age']: 8
>>>
>>> print("dict['School']: ", dict['School'])
dict['School']: 菜鸟教程

删除字典元素

能删除单一的元素也能清空字典，清空只需一项操作。

1
2
3
4
5
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> del dict['Name'] # 删除键 'Name'
>>> dict.clear() # 清空字典
>>> del dict # 删除字典
>>> print("dict['Age']: ", dict['Age'])  # 会报错 TypeError

字典键的特性

字典值可以是任何对象，既可以是标准的对象，也可以是用户定义的，但键不行。

  • 不允许同一个键出现两次。创建时如果同一个键被赋值两次后，后一个值会被记住。
    1
    2
    3
    >>> dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
    >>> print("dict['Name']: ", dict['Name'])
    dict['Name']: 小菜鸟
  • 键必须不可变，可以用数字，字符串或元组，但是列表不行。
    1
    >>> dict = {['Name']: 'Runoob', 'Age': 7}  # 会报错 TypeError

字典内置的函数与方法

  • 函数
1
2
3
4
5
6
7
8
9
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(dict) # 计算字典对象的个数，即键的总数
3
>>>
>>> str(dict) # 输出字典，以可打印的字符串表示
"{'Name': 'Runoob', 'Age': 7, 'Class': 'First'}"
>>>
>>> type(dict) # 返回输入的变量类型
<class 'dict'>
  • 方法
序号 表达式 描述
1 dict.clear() 删除字典内所有元素
2 dict.copy() 返回一个字典的浅复制
3 dict.fromkeys() 创建一个新字典
4 dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回 default 值
5 key in dict 如果键在字典 dict 里返回 True，否则返回 False
6 dict.items() 以列表返回可遍历的（键，值）元组数组
7 dict.keys() 以列表返回一个字典所有的键
8 dict.setdefault(key, default=None) 和 get() 类似，但如果键不存在与字典中，将会添加键并将值设为 default
9 dict.update(dict2) 把字典 dict2 的键值对更新到 dict 里
10 dict.values() 以列表返回字典中的所有值
11 dict.pop(key [, default]) 删除字典给定键 key 所对应的值，返回值为被删除的值，key 值必须给出。否则返回 default 值
12 dict.popitem() 随机返回并删除字典中的一对键和值（一般删除末尾对）

内置函数

函数名 描述
list() 列表
range() 指定范围的数值
enumerate() 对数据列表编号，从0开始
int() 转换为整型
id() 对一个对象生成标识
next() 返回一个可迭代数据结构的下一项
推荐文章