Python 数据类型和运算符

变量命名

在 python 中，变量名称的命名方式是全部使用小写字母，并用下划线区分单词。也称 snake case。

逻辑运算符

你需要熟悉三个逻辑运算符：

逻辑使用情况	布尔型	运算符
5 < 3 and 5 == 5	False	and - 检查提供的所有语句是否都为 True
5 < 3 or 5 == 5	True	or - 检查是否至少有一个语句为 True
not 5 < 3	True	not - 翻转布尔值

字符串

在 python 中，字符串的变量类型显示为 str。你可以使用双引号 ” 或单引号 ’ 定义字符串。如果你要创建的字符串包含其中一种引号，你需要确保代码不会出错。

type()，检查变量类型非常重要，可以确保在编程时你所获的结果是你想要的结果。不同类型，每种类型都有自己的一组不同的行为。

我们可以用旧的对象创建新的对象，并在创建过程中更改类型。

grams = "35.0"
print(type(grams))
grams = float(grams)
print(type(grams))

...
# 输出为
<class 'str'>
<class 'float'>

python 中的方法和函数相似，但是它针对的是你已经创建的变量。方法特定于存储在特定变量中的数据类型。

字符串方法

任何专业人士都无法记住所有方法，因此知道如何通过文档查询答案非常重要。掌握扎实的编程基础使你能够利用这些基础知识查询文档，并且构建的程序比死记硬背所有 python 可用函数的人士构建的程序强大得多。

要详细了解字符串和字符串方法，请参阅字符串方法文档。

列表切片

列表中可以混合使用多种数据类型，比如

lst_of_random_things = [1, 3.4, 'a string', True]

slicing notation-切片记法，我们可以使用列表切片从列表中提取多个值。记住，前包含后不包含。

>>> lst_of_random_things = [1, 3.4, 'a string', True]
>>> lst_of_random_things[1:2]
[3.4]

仅返回列表中的 3.4。注意，这与单个元素索引依然不同，因为你通过这种索引获得了一个列表。冒号表示从冒号左侧的起始值开始，到右侧的元素（不含）结束。

如果你要从列表的开头开始，也可以省略起始值。

>>> lst_of_random_things[:2]
[1, 3.4]

或者你要返回到列表结尾的所有值，可以忽略最后一个元素。

>>> lst_of_random_things[1:]
[3.4, 'a string', True]

在不在列表中

我们还可以使用 in 和 not in 返回一个布尔值，表示某个元素是否存在于列表中，或者某个字符串是否为另一个字符串的子字符串。

>>> 'this' in 'this is a string'
True
>>> 'in' in 'this is a string'
True
>>> 'isa' in 'this is a string'
False
>>> 5 not in [1, 2, 3, 4, 6]
True
>>> 5 in [1, 2, 3, 4, 6]
False

可变性和顺序

MUTABILITY（可变性）表示对象创建之后是否可以修改。我们可以修改列表的值类型，因此列表是可变数据类型。我们无法修改字符串，因此字符串是不可变数据类型。

# 不可变对象
name = 'Jim'
student = name
name = 'Tim'
print(name)
print(student)
# 输出
Tim
Jim

# 列表和字符串不同，因为它们是可变的
scores = ['B', 'C', 'A', 'D', 'B', 'A']
grades = scores
print('scores: ' + str(scores))
print('grades: ' + str(grades))
scores[3] = 'B'
print('scores: ' + str(scores))
print('grades: ' + str(grades))
# 输出
scores: ['B', 'C', 'A', 'D', 'B', 'A']
grades: ['B', 'C', 'A', 'D', 'B', 'A']
scores: ['B', 'C', 'A', 'B', 'B', 'A']
grades: ['B', 'C', 'A', 'B', 'B', 'A']

注意，包含可变对象和不可变对象变量行为非常不同。

ORDER 是指对象的内容顺序是否重要，以及是否可以利用该 ORDER 访问对象的某个部分。字符串和列表都是有序的，因此可以使用索引。但是它们又分别是不可变和可变。

了解数据结构的这些信息很有用！此外，你将发现每种数据类型有不同的方法，因此为何使用一种数据类型（而不是另一种）在很大程度上取决于这些特性，以及如何轻松地利用这些特性！

实用列表函数

max，返回列表中的最大元素。最大元素的判断依据是列表中的对象类型。数字列表中最大的元素是最大的数字。字符串列表中最大的元素是按照字母顺序排列时排在最后一位的元素。如果列表包含不同的无法比较类型的元素，则 max() 的结果是 undefined。

min()，返回列表中的最小元素。它和 max() 函数相对立。

sorted()，返回一个从最小到最大排序的列表副本，并使原始列表保持不变。

sizes = [15, 6, 89, 34, 65, 35]
print(sorted(sizes))
# 输出
[6, 15, 34, 35, 65, 89]

我们也可以添加可选参数 reverse = true，按照从大到小的顺序排列。

sizes = [15, 6, 89, 34, 65, 35]
print(sorted(sizes， reverse = True))
# 输出
[89, 65, 35, 34, 15, 6]

join()

字符串方法，将字符串列表作为参数，并返回一个由 列表元素组成 并由分隔符字符串 分隔的 字符串。分隔符如果是逗号，应为英文逗号 ,。忘记分隔符，不会触发错误，但会产生意外的结果。

new_str = "\n".join(["fore", "aft", "starboard", "port"])
print(new_str)
...
# 输出
fore
aft
starboard
port

在如上示例中，我们使用字符串 "\n" 作为分隔符，以便每个列表元素之间都有一个换行符。

append()，将元素添加到列表末尾。

letters = ['a', 'b', 'c', 'd']
letters.append('z')
print(letters)
...
# 输出
['a', 'b', 'c', 'd', 'z']

元组

元组（tuple）是另一个实用容器。它是一种不可变有序元素数据类型。通常用来存储相关的信息。

# 经纬度
location = {13.4125, 103.866667}
print("Latitude:", location[0])
print("Longitude:", location[1])

元组和列表相似。他们都存储一个有序的对象集合，并且可以通过索引访问这些对象。但是与列表不同的是，元组不可变，你无法向元组中添加项目或从中删除项目，或者直接对元组排序。

元组还可以用来以紧凑的方式为多个变量赋值。

dimensions = 52, 40, 100
length, width, height = dimensions
print("The dimensions are {} x {} x {}".format(length, width, height))
# 输出
The dimensions are 52 x 40 x 100

在定义元组时，小括号是可选的，如果小括号并没有对解释代码有影响，程序员经常会忽略小括号。

在第二行，我们根据元组 dimensions 的内容为三个变量赋了值，这叫做元组解包。你可以通过元组解包将元组中的信息赋值给多个变量，而不用逐个访问这些信息，并创建多个赋值语句。

如果我们不需要直接使用 dimensions 变量名，可以将这两行代码简写为一行，一次性为三个变量赋值！

length, width, height = 52, 40, 100
print("The dimensions are {} x {} x {}".format(length, width, height))

集合

集合是一个包含唯一元素的可变 无序集合数据类型。集合的一个用途是快速删除列表中的重复项。

numbers = [1, 2, 6, 3, 1, 1, 6]
unique_nums = set(numbers)
print(unique_nums)
# 输出
{1, 2, 3, 6}

集合和列表一样支持 in 运算符。和列表相似，你可以使用 add() 方法将元素添加到集合中，并使用 pop() 方法删除元素。但是，当你从集合中拿出元素时，会随机删除一个元素。注意和列表不同。集合是无序的，因此没有“最后一个元素”。

fruit = {"apple", "banana", "orange", "grapefruit"}  # define a set

print("watermelon" in fruit)  # check for element

fruit.add("watermelon")  # add an element
print(fruit)

print(fruit.pop())  # remove a random element
print(fruit)

# 输出
False
{'grapefruit', 'orange', 'watermelon', 'banana', 'apple'}
grapefruit
{'orange', 'watermelon', 'banana', 'apple'}

你可以对集合执行的其他操作包括可以对数学集合执行的操作。可以对集合轻松地执行 union()-并集、intersection()-交集 和 difference() 等方法，并且与其他容器相比，速度快了很多！

字典和恒等运算符

字典

字典（dictionaries）是可变数据类型，其中存储的是唯一键到值的映射，而不是像列表或集合一样存储的是单个对象。下面是存储元素和相应原子序数的字典。

elements = {"hydrogen": 1, "helium": 2, "carbon": 6}

字典的键是元素名称，值是相应的原子序数。键可以是任何不可变类型，例如整数或元组，而不仅仅是字符串。甚至每个键都不一定要是相同的类型！字典的键和列表的索引相似，我们可以使用方括号并在括号里放入键，查询字典中的值或向字典中插入新值。如果方括号中键入的键不在字典中，程序会报错显示 KeyError ！！。

print(elements["helium"])  # print the value mapped to "helium"
elements["lithium"] = 3  # insert "lithium" with a value of 3 into the dictionary

我们可以像检查某个值是否在列表中一样，使用关键字 in 检查值是否在字典中。我们在查找键之前，使用 in 验证该键是否在字典中，有可能该键不在字典中。

字典有一个也很有用的相关方法，叫做 get()。get 会在字典中查询值，但是和方括号不同，如果没有找到键，get 会返回 None（或者你所选的默认值）。

print("carbon" in elements)
print(elements.get("dilithium"))
# 输出
True
None

我们也可以指定一个默认值，当键没找到时，get() 返回该值。

population = {"Shanghai": 17.8, "Istanbul": 13.3, "Karachi": 13.0, "Mumbai": 12.5}
m = population.get("Nanjing")
n = population.get("Nanjing", "There's no such element!");
print(m)
print(n)
# 输出
None
There's no such element!

carbon 位于该字典中，因此输出 True。dilithium 不在字典中，因此 get 返回 None，然后系统输出 None。如果你预计查询有时候会失败，get 可能比普通的方括号查询更合适，因为错误可能会使程序崩溃。

恒等运算符

关键字	运算符
is	检查两边是否恒等
is not	检查两边是否不恒等

我们可以用 is 运算符检查键是否返回了 None ，或者使用 is not 检查相反的情况。

elements = {"hydrogen": 1, "helium": 2, "carbon": 3}
print(elements["hydrogen"])
print(elements.get("a"))
n = elements.get("a")
print(n is None);
print(n is not None)
# 输出
1
None
True
False

==（相等） 与 is（恒等） 的关系？

== 相等只要求内容等式两边内容（格式，类型等）相同。而 is 全等则更为严格，不光要求内容，还要求对象相同。

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(a == b)
print(a is b)
print(a == c)
print(a is c)
# 输出
True
True
True
False

复合数据结构

容器中包含容器，以创建复合数据结构。

elements = {"hydrogen": {"number": 1,
                         "weight": 1.00794,
                         "symbol": "H"},
              "helium": {"number": 2,
                         "weight": 4.002602,
                         "symbol": "He"}}

helium = elements["helium"]  # get the helium dictionary
hydrogen_weight = elements["hydrogen"]["weight"]  # get hydrogen's weight
# 输出
{'number': 2, 'weight': 4.002602, 'symbol': 'He'}

总结

Data Structure	Ordered	Mutable	Constructor	Example
int	NA	NA	int()	5
float	NA	NA	float()	6.5
string	Yes	No	’ ’ or ” ” or str()	“this is a string”
bool	NA	NA	NA	True or False
list	Yes	Yes	[ ] or list()	[5, ‘yes’, 5.7]
tuple	Yes	No	( ) or tuple()	(5, ‘yes’, 5.7)
set	No	Yes	{ } or set()	{5, ‘yes’, 5.7}
dictionary	No	Keys: No	{ } or dict()	{‘Jun’:75, ‘Jul’:89}