数字 (Number)

数字的类型


整数 (int)

python 自带高精，所以不需要注意范围问题。

1
2
a = 10
print(type(a))


浮点数 (float)

注意浮点数的精度问题。


布尔型 (bool)

构造布尔型：

1
2
3
4
5
a = True
a = False
a = bool(0)
a = bool('')
a = bool([])


Remark:

变量只是一个标签，对象有类型，变量无类型。


运算

  1. 赋值：=

  2. 加减乘：+, -, *

  3. 除：/

  4. 取余（模）：%

  5. 整除：//

  6. 四舍五入：round(number, digits)

  7. 取绝对值：abs(number)

  8. 指数：**


强制类型转换

数字之间可以进行强制类型转换，建议使用如下的显示转换方式：

1
2
3
a = True
a = int(a)
print(type(a))


字符串 (String - str)

1
2
s = "Hello World !"
print(type(s))


单引号与双引号

当字符串内出现单引号时，要用双引号引起来。


转义字符

  1. \n：换行

  2. \r：回车

  3. \t：制表符


索引和切片

1
2
3
4
5
6
s = "1234567890"
num1 = 1
num2 = 9
num3 = 2

print(s[num1: num2: num3])


num1 是左端点，num2 是右端点， num3 是步长。切片包括左端点，不包括右端点，可以理解为一个左闭右开区间。字符串从 0 开始索引，可以理解为相对于起始位置的偏移量。


不可改变字符串的某个字符。


常用操作

  1. len(str)：返回序列的长度

  2. +：连接两个字符串

  3. in：判断元素是否在序列中

  4. max(str), min(str)：返回字符串中的最大（小）值（依据 ACSII 编码）

  5. *：重复序列元素

  6. str1.split(str2)：将 str1 以 str2 为分隔符分割，返回一个列表

  7. str.strip()：去掉左右两边的空格，str.lstrip(), str.rstrip() 去掉左（右）边的空格

  8. str.upper(), str.lower()：转为大（小）写

  9. str.isupper(), str.islower()：检查是否全为大（小）写，非字母会返回 False

  10. str.count(x)：返回 x 在 str 中出现的次数


序列：元素以人定的顺序排列的一组数据。


编码

在 Python3 中，所有的字符串均是以 Unicode 码存储的


UTF-8 $\to$ decode $\to$ Unicode

Unicode $\to$ encode $\to$ GBK / UTF-8


列表 (list)

1
2
lst = [1, 2, 3]
print(type(lst))


List 里面的元素可以是任意类型的


索引和切片

与 String 相同，但是 List 是以元素为单位，而不是以字符为单位。

List 也属于序列，但是可以被修改。


常用操作

  1. len(lst), +, in, max(lst), min(lst), *：与字符串相同

  2. lst.append(x)：将 x 作为一个整体加入 lst

  3. lst.extend(x)：将 x 中的元素拆开加入 1lst，x 必须为可迭代类型

  4. lst2 = lst1.copy()：返回 lst1 的浅复制

  5. lst.count(x)：返回 x 在 lst 中出现的次数

  6. lst.index(x)：返回 x 在 lst 中第一次出现的索引

  7. lst.insert(i, x) 向索引 i 处插入元素 x

  8. lst.remove(x)：删除列表中出现的第一个 x

  9. del lst[i]：删除第 i 个元素

  10. lst.pop(i)：删除第 i 个元素，并返回

  11. lst.reverse()：把列表中的元素反转

  12. lst.sort(key=None, reverse=False)：从小到大排序，key 是一个函数，对每个元素执行这个函数以决定排序规则，reverse 为 True 时按从大到小排序


可迭代：字符串、列表、元组、字典都是可迭代的。

list.count(x) 和 str.count(x) 的区别：str.count(x) 可以设置起始和结束位置，而 list.count(x) 不行

直接赋值、深拷贝、浅拷贝：

  1. 直接赋值：b = a，赋值引用，a 和 b 都指向同一个对象。

  1. 浅拷贝：b = a.copy()，a 和 b 是两个独立的对象，但他们的子对象还是指向统一对象（是引用）。

  1. 深拷贝：b = copy.deepcopy(a)，a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

元组 (Tuple - tuple)

1
2
tp = (1, 2, 3)
print(type(tp))


元组是序列，但是元素不能更改


索引和切片

与 List 相同


列表和元组的相互转化

1
2
3
4
5
6
7
8
a = [1, 2, 3, 4]
b = ['a', 'b', 'c', 'd']

zipped = list(zip(a, b))
print(zipped)

zipped = list(zip(*zipped))
print(zipped)


元组的用途

  1. 元组比列表操作速度快

  2. 可以对不需要修改的数据写保护（因为不能被修改）

  3. 可以在字典中当作 key（同样因为不能修改）


字典 (Dictionary - dict)

1
2
dct = {1: 'a', 2: 'b', 3: 'c'}
print(type(dct))


1，2，3 被称为键 (key)，’a’，’b’，’c’ 被成为值 (value)

key 必须是唯一的、不可变的，value 则不一定。

字典不是序列


常用操作

  1. len(dct)：返回 dct 中键值对的数量

  2. del dct[key], dct.pop(key)：删除 key 对应的键值对

  3. key in dct：判断 dct 中是否存在 key

  4. dct.clear()：删除所有键值对

  5. dct1 = update(dct2)：把 dct1 的键值对更行到 dct1 里

  6. dct.get(key, default = None)：得到字典中 key 对应的值，若没有则返回 default


dct.clear() $\ne$ del dct：‘空’ 不等于 ‘无’


总结

在这里插入图片描述