1. 数字类型

1.0 type()函数

type(变量)
print(type(变量)) #打印出变量的数据类型

1.1 int

不需要像 C/C++ 一样先定义，直接声明即可。

a = 2
print(type(a))

1.2 float

与 C/C++ 不同，Python 中的 float 精度更高，范围在 -3.4028235 x 10^38 ~ 3.4028235 x 10^38 之间。

a = 2.333
b = 5.
print(type(a))
print(type(b))

1.3 complex

在 Python 中可以直接表示复数类型。

a = 1 + 2j
print(type(a))

2. 运算符

2.1 除法

• 除法：/
• 向下取整除法 ：//

a = 10
b = 3
c = a / b
d = a // b
print("c: ", c, type(c))
print("d: ", d, type(d))

可以得知，/ 运算返回一个 float 类型，而 // 返回 int 类型。

2.2 取余

• 取余：%

a = 10
b = 3
c = a % b
d = b % a
print("c: ", c, type(c))
print("d: ", d, type(d))

% 运算返回 int 类型。

2.3 乘法

• 乘法：*
• 乘方：**

a = 10
b = 3.0
c = a * b
d = a ** b
print("c: ", c, type(c))
print("d: ", d, type(d))

* 或 ** 运算返回精度更高的类型。

3. 字符串

3.1 基本操作

声明即可赋值：

a = 'abcd'
b = "abcd"
c = """abcd"""
print("a: ", a, type(a))
print("b: ", b, type(b))
print("c: ", c, type(c))
print(a, b, c)

\ 用于转义，例如：

# a = 'a'bc'd' 错误语句
b = "a'bc'd"
c = "a\'bc\'d"
# print("a: ", a, type(a))
print("b: ", b, type(b))
print("c: ", c, type(c))

取消全部的转义在前面加上 r：

print("a\nbcd")
print(r"a\nbcd")

字符串字面值可以包含多行，使用三重引号："""...""" 或 '''...'''：

a = """
    'a' is a string
    Python is instring
"""
print(a)

使用 + 进行拼接，* 进行重复：

a = "abcd"
b = "efgh"
c = a + b
d = a * 2 + b * 3
print("c: ", c, type(c))
print("d: ", d, type(d))

3.2 索引和切片

3.2.1 索引

字符串支持索引（下标访问），第一个字符的索引是 0，单个字符没有专用的类型，就是长度为一的字符串：

a = "abcd"
print(a[0])
print(a[2])

索引支持负数，用负数索引时，从右边开始计数：

a = "abcd"
print(a[0])
print(a[-0])  #-0 和 0 一样
print(a[1])
print(a[-1])  #负数索引从 -1 开始

Python 字符串不能修改，是 immutable 的：

a = "abcd"
# a[0] = "d"  报错

3.2.2 切片

索引可以提取单个字符，切片则提取子字符串：

• 语法：str[起始位:终止位:步长]
• 省略开始索引时，默认值为 0，省略结束索引时，默认为到字符串的结尾。
• 切片开始包括起始位元素，截至到终止位的前一个元素，即不包含终止位元素。
• 其中步长可省略，默认为1，切片返回一个新的字符串。

a = "abcd"
b = a[0:2]
c = a[2:4]
d = a[:2]
e = a[2:]
f = a[:]
g = a[0:4:2]
h = a[-1::-1]
i = a[0:100]
print(b)
print(c)
print(d)  #起始索引默认为 0
print(e)  #结束索引默认为字符串结尾
print(f)
print(g)  #步长为 2，每 2 个元素取一个
print(h)  #步长为负数，从左往右切
print(i)  #切片越界自动处理

注意：索引越界会报错，切片越界会自动处理。

3.3 常用内置函数

a = "lys is a dog"
print(len(a))  #len() 返回字符串的长度，

print(a.title())  #给每个单词首字母大写
print(a.upper())  #把所有字母变成大写
a = a.upper()
print(a.lower())  #把所有字母变成小写

b = "   lys is a dog   "
print(b.lstrip())  #去除头空格
print(b.rstrip())  #去除尾空格
print(b.strip())  #去除头尾空格

4. 列表与元组

Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同：

a = [1, 2, 3, 4]
b = ['a', 'b', 'c', 'd']
c = ['a', '2', '3.33', "cde"]
d = a + b  #支持 + 合并
e = c * 2 + d * 3  # 支持 * 合并
print("a: ", a, type(a))
print("b: ", b, type(b))
print("c: ", c, type(c))
print("d: ", d, type(d))
print("e: ", e, type(e))

4.1 列表索引和切片

4.1.1 索引

和数组操作相同：

a = [1, 2, 3, 4]
b = ['a', 'b', 'c', 'd']
c = ['a', '2', '3.33', "cde"]
print(a[0])
print(b[1])
print(c[2])

与 immutable 字符串不同, 列表是 mutable 类型，其内容可以改变：

a = [1, 2, 3, 4]
b = ['a', 'b', 'c', 'd']
c = ['a', '2', '3.33', "cde"]
a[0], b[1], c[2] = 100, 'x', "abc"
print("a: ", a, type(a))
print("b: ", b, type(b))
print("c: ", c, type(c))

4.1.2 切片

切片操作返回包含请求元素的新列表，切片操作会返回列表的浅拷贝：

a = [1, 2, 3, 4]
b = a[0:2]
c = a[2:]
print(b)
print(c)

4.2 嵌套列表

a = [1, 2, 3, 4]
b = ['a', 'b', 'c', 'd']
c = ['a', '2', '3.33', "cde"]
e = [a, b, c]
print("e: ", e, type(e))
print(e[0][0], e[1][1], e[2][2])

4.3 列表常用内置函数

a = [1, 2, 3, 4]
print("len(a): ", len(a))  #len() 返回列表的长度

a.append(5)  #在 a 末尾添加元素 5
print("a.append(5): ", a)

a.insert(1, 3)  #在位置 1 处插入元素 3
print("a.insert(1, 3): " ,a)

a.remove(3)  #删除第一个值为 3 的元素
print("a.remove(3): ", a)
#a.remove(0)  删除的元素不存在则会触发 ValueError 异常

a.pop(0)  #pop(i) 删除指定位置 i 的元素
print("a.pop(0):", a)
a.pop()  #未传入参数时默认删除末尾元素
print(a)

a = [1, 2, 3, 4, 5]
del a[1:3]  #删除列表的切片
print("del a[1:3]:", a)

a = [6, 5, 4, 3, 2, 1, 1]
print("a.count(1): ", a.count(1))  #count(x) 返回值为 x 的元素出现的次数

a.sort()  #默认从小到大排序
print("a.sort(): ", a)
a.sort(reverse=True)  #传入参数从大到小排序
print("a.sort(reverse=True): ", a)

a.reverse()  #翻转列表中的元素
print("a.reverse()", a)

a.clear()  #清空
print(len(a))

4.4 元组

元组由多个用逗号隔开的值组成：

a = 1, 2, 3, 4
print("a: ", a, type(a))
b = ('a', 'b', 'c', 'd', a)  #由 () 表示一个元组，可嵌套使用
print("b: ", b, type(b))

输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无，不过经常是必须的（如果元组是更大的表达式的一部分）。不允许为元组中的单个元素赋值，当然，可以创建含列表等可变对象的元组。

元组同样支持索引和切片：

a = 1, 2, 'a', 'b'
print(a[0])
print(a[1:3])
#a[0] = 0  不可修改

虽然，元组与列表很像，但使用场景不同，用途也不同。元组是 immutable （不可变的），一般可包含异质元素序列，通过解包索引访问（如果是 namedtuples，可以属性访问）。列表是 mutable （可变的），列表元素一般为同质类型，可迭代访问。

5. 集合与字典

5.1 集合

集合是由不重复元素组成的无序容器，基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算。

a = {1, 2, 3, 4, 5}
print("a: ", a, type(a))

集合运算：

a = {1, 2, 3, 4, 5}
b = {2, 4, 5}
print("1 in a is", 1 in a)
print("1 in b is", 1 in b)
print("a = b is", a == b)
print("a - b =", a - b)
print("b - a =", b - a)
print("a | b =", a | b)
print("a & b =", a & b)
print("a ^ b =", a ^ b)

5.2 字典

字典为键值对的集合，字典的键必须是唯一的：

a = {1:'a', 2:'b', 3:'c', 4:'d'}
print("a: ", a, type(a))
print("a[1]: ", a[1])

b = {'a':1, "bcd":2, 3.4:"e"}
print("b: ", b, type(b))
print("b['a']: ", b['a'])

与以连续整数为索引的序列不同，字典以关键字为索引，关键字通常是字符串或数字，也可以是其他任意不可变类型。只包含字符串、数字、元组的元组，也可以用作关键字。但如果元组直接或间接地包含了可变对象，就不能用作关键字。列表不能当关键字，因为列表可以用索引、切片、append() 、extend() 等方法修改。

a = {'name': 'wjq', 'sex': 'male', 'qq': 1145141919}
print(a.get('name'))  #通过键获取值，且不会报错
a.pop('qq')  #删除键为 qq 的键值对
print(a.keys())  #获取所有的键
print(a.values())  #获取所有的值
a['name'] = 'lys'  #改值
print("a: ", a, type(a))