Python---基本数据类型

注释

  在开始本节内容之前，我们先来讲讲注释的作用。注释是用来给人看的，并不会被解析器解析。换句话来说注释后面的内容并不会在你的程序中有任何作用，因为解析器会忽略掉它，它是用来给程序添加说明的，是给程序员看的。当然它有时候也会用来debug，当将某段内容注释掉之后，代码无报错或bug消失，那么问题就出现在我们注释掉那一块内容里，可以极大程度地提升我们debug的效率。

单行注释

  单行注释指的是一次性注释掉一行的内容。#开头的语句表示单行注释。
  代码示例：

	# print("我是一个注释")
	print("我不是一个注释")
	# print("我也是一个注释")
	print("^w^")

  运行结果

	我不是一个注释
	^w^

多行注释

  多行注释指一次性注释多行内容(包括单行)。连续3个单引号‘’'或者连续3个双引号“”"。
  代码示例1：

	'''
	print("我被一个奇怪的符号包围住了")
	print("我不知道我最后能不能打印出来")
	print("有人知道的话，可以告诉我吗？")
	'''
	print("别想了，你打印不出来的")
	print("因为你被多行注释给包围了")

  代码示例2：

	"""
	print("我被一个奇怪的符号包围住了")
	print("我不知道我最后能不能打印出来")
	print("有人知道的话，可以告诉我吗？")
	"""
	print("别想了，你打印不出来的")
	print("因为你被多行注释给包围了")

  代码示例3：

	"""print("我被一个奇怪的符号包围住了")print("我不知道我最后能不能打印出来")"""
	'''print("有人知道的话，可以告诉我吗？")'''
	print("别想了，你打印不出来的")
	print("因为你被多行注释给包围了")

  上述的3个示例的运行结果都是一样的，如下。
  运行结果

	别想了，你打印不出来的
	因为你被多行注释给包围了

注意事项

  1. 多行注释要成对存在，即如果前面如果出现了3个单引号‘’'或者3个双引号“”"，那么需要注释的内容的后面也需要出现3个单引号‘’'或者3个双引号“”"用来表示注释结束，否则程序会报错。
  错误示例：

	print("我来组成头部")
	'''
	print("我来组成躯干")
	print("我来组成四肢")

  2. 多行注释是不支持嵌套的。第一个出现的多行注释符会与接下来内容中最近的一个多行注释符组成一对。
  代码示例：

	'''
	print("我来组成头部")
	'''
	print("我来组成躯干")
	'''
	'''
	print("我来组成四肢")

  运行结果

	我来组成躯干
	我来组成四肢

  3. 当注释出现在字符串里时，不能再把它们当成注释了，而应该是字符串的一部分。字符串是什么呢？来这里看看呗。
  代码示例：

	print("#你猜猜我现在这个样子可不可以打印出来？")
	print("""那现在这个样子呢？""")
	print('''这样呢？''')

  运行结果

	#你猜猜我现在这个样子可不可以打印出来？
	那现在这个样子呢？
	这样呢？

变量与常量

  变量：在程序运行期间，值可以变化的量。
  常量：在程序运行期间，值不可以变化的量。
  我们换个比较形象的例子来理解一下。变量就相当于一个有开口的箱子，我们可以放入不同颜色的球。而常量就相当于一个完全封闭的箱子，箱子里原先装着什么颜色的球，那么它就一直在里面，我们不可以放入其他颜色的球。
  因为Python的动态语言特性，变量不需要声明类型。
  代码示例1：

	var = 4
	print(var)

  运行结果：

	4

  示例1讲解：

	第1行：var就是一个变量，而var是它的名字。4就是一个常量(数值类型中的整型)。‘=’与数学中的‘等于’不是同一个意思，这里的'='是赋值的意思。整
句话的意思就是：将常量4的值赋给了变量var，此时变量var的值也是4。
	第2行：print的'()'中也可以放入变量名，最后输出的是变量var的值。

  在程序运行期间，变量存储的数据类型可以发生改变。
  代码示例2：

	var = 4
	print(var)
	var = "Hello World!"
	print(var)

  运行结果：

	4
	Hello World!

  示例2讲解：

	第1行：将整型常量4的值赋值给了变量var，此时变量var中存储的是一个整型的数据，值为4。
	第2行：打印变量var中存储的值。
	第3行：将字符串常量"Hello World!"赋值给了变量var，此时变量var中存储的是一个字符串类型的数据，值为Hello World!
	第4行：打印变量var中存储的值。

数值类型

  Python的数值类型有：整数(int)、浮点数(float)、复数(complex)和布尔值(bool)。下面我们逐个进行了解。

整数类型(int)

  整数类型也就是我们数学中常说的整数，无取值范围。
  整数类型我们可以使用二进制、八进制、十六进制等方式进行表示。
  代码示例：

	num = 0b1001	# 二进制表示格式：以0b或0B开头；后面每一位的内容仅可填写0或1
	print(num)
	num1 = -0o765	# 八进制表示格式：以0o或0O开头；后面每一位的内容仅可填写0~7之间的任意值
	print(num)
	num = 527		# 十进制表示格式：321或987；后面每一位的内容仅可填写0~9之间的任意值
	print(num)
	num1 = -0xFE	# 十六进制表示格式：以0x或0X开头；后面每一位的内容仅可填写0~9或a~f或A~F之间的任意值
	print(num)

  运行结果：

	9
	-501
	527
	-254

  print在打印的时候会将其它不是十进制数的整数类型转换成十进制来表示。
  示例讲解：

	第1行：0b1001 = 0o11 = 9 = 0x09，将0b1001的值赋给num，现在num的值是0b1001
	第2行：打印num的值
	第3行：-0b111110101 = -0o765 = -501 = -0x1F5，将-0o765的值赋给num，现在num的值是-0o765
	第4行：打印num的值
	第5行：0b1000001111 = 0o1017 = 527 = 0x20F，将527的值赋给num，现在num的值是527
	第6行：打印num的值
	第7行：-0b11111110 = -0o376 = -254 = -0xFE，将0b1001的值赋给num，现在num的值是-0xFE
	第8行：打印num的值

浮点数类型(float)

  浮点数也就是数学中所说的小数，由整数部分和小数部分组成，存在取值范围。
  浮点数有常规表示法和科学计数法两种表示方式。
  常规表示法：3.12。
  科学计数法：字母e或E作为幂的符号，以10位基数，格式：a*10^b = aeb。
  例子：0.000536 = 5.36 * 10^-4 = 5.36e-4；952700 = 9.527 * 10⁵ = 9.527E5。
  代码示例1：

	num1 = 0.1
	num2 = 2e-1
	print(num1, num2)
	num1 = num1 + num2
	print(num1, num2)

  运行结果：

	0.1 0.2
	0.30000000000000004 0.2

  示例1讲解：

	第1行：将值0.1赋给num1
	第2行：将值2e-1赋给num2
	第3行：打印num1和num2的值。print()其实是可以连续打印多个内容的，就像“print(num1, num2)”这样，将要打印的内容与内容之间用“,”隔开。
	第4行：将num1当前的值与num2当前的值相加得到后的和赋给num1。
	第5行：打印num1和num2的值。第4行中的0.1加0.2不是等于0.3吗？为什么最后打印出来的东西会多出这么一长串的东西呢？这是因为浮点数直接运算，
可能产生不确定尾数。不确定尾数问题来源于浮点数在计算机中表示不精确的实际情况，广泛存在于编程语言中。想要消除这个不确定的尾数，我们可以使用
函数round(number, ndigits)，参数number填入我们要进行处理的数值，参数ndigits填入要保留的小数位数。感兴趣的小伙伴可以将本示例改成如下示例，
看看输出的结果是什么。

  代码示例2：

	num1 = 0.1
	num2 = 2e-1
	print(num1, num2)
	num1 = num1 + num2
	num1 = round(num1, 1)
	print(num1, num2)

复数类型(complex)

  复数类型也就是数学上的复数。形如 z = a + bi 的数称为复数。其中 i 为虚数单位，且 i² = -1；a被称为实部，b被称为虚部。
  当虚部b = 0 时，则z为实数；当z的虚部b ≠ 0时，实部a = 0时，z被称为纯虚数。
  在python中，表示复数的格式为：a + bj
  代码示例：

	z = 10 + 25j
	print(z)

  运行结果：

	(10+25j)

布尔类型(bool)

  布尔类型只有 True 和 False 两种值。要么是 True,要么是 False，不能是其他值。
  布尔类型除了可以直接赋予True或False，还可以通过布尔运算出来。
  代码示例1：

	temp = 3 > 5
	print(temp)
	temp = 3 < 5
	print(temp)

  运行结果：

	False
	True

  示例1讲解：

	第1行：因为3不大于5，所以“=”右边的值为False，然后将该False的值赋给temp
	第2行：打印temp的值
	第3行：因为3小于5，所以“=”右边的值为True，然后将该True的值赋给temp
	第4行：打印temp的值

  布尔值之间也是可以通过and、or和not进行运算的。
  and：与运算。只有左右两边都为True时，最终的结果才为True，否则为False。
  or：或运算。只要左右两边有一个为True，那么最终结果就为True，否则为False。
  not：非运算。它时一个单目运算符，用来将True变成False，False变成True。
  代码示例2：

	temp = 3 > 5 and 3 < 5
	print(temp)
	temp = 6 > 5 and 3 < 5
	print(temp)
	temp = 3 > 5 or 3 < 5
	print(temp)
	temp = 3 > 5 or 5 > 6
	print(temp)
	temp = not 3 > 5
	print(temp)
	temp = not 3 < 5
	print(temp)

  运行结果：

	False
	True
	True
	False
	True
	False

  示例2讲解：

	第1行：3 > 5的结果为False，3 < 5的结果为True，and左右两边没有都为True，所以结果为False，并将该False值赋给temp
	第2行：打印temp的值
	第3行：6 > 5的结果为True，3 < 5的结果为True，and左右两边都为True，所以结果为True，并将该True值赋给temp
	第4行：打印temp的值
	第5行：3 > 5的结果为False，3 < 5的结果为True，or左右两边有1个True，所以结果为True，并将该True值赋给temp
	第6行：打印temp的值
	第7行：3 > 5的结果为False，5 > 6的结果为False，or左右两边没有True，所以结果为False，并将该False值赋给temp
	第8行：打印temp的值
	第9行：3 > 5的结果为False，not将False转变成True，所以结果是True，然后将该True值赋给temp
	第10行：打印temp的值
	第11行：3 < 5的结果为True，not将True转变成False，所以结果是False，然后将该False值赋给temp
	第12行：打印temp的值

字符串类型

  字符串就是任意文本，它是由单引号 ' 或双引号 " 框起来的。例：'123abc’或者"asdfcz"等等。其中 ’ 和 " 是用来标识字符串的，而不属于字符串中的一部分。所以字符串“asdfcz”中只有a、s、d、f、c、z这6个字符。
  代码示例1：

	str = "Hello World!"
	print(str)

  运行结果：

	Hello World!

  那如果我们要在字符串中显示 ’ 、 " 和 \ 等等这些字符应该怎么办呢？这个时候我们可以借助转义字符 \ 。
  代码示例2：

	str = "What\'s your name?"
	print(str)
	print("My name is \"凛雨\"")

  运行结果：

	What's your name?
	My name is "凛雨"

  下面列出一下比较常用的几个转义字符的用法。如果大家想知道还有什么其他的转义字符的话，可以百度搜索。

转义符号	作用	Python代码示例	输出结果	备注
\n	换行	print("1\n2\n3")	1 2 3	会将光标移动到下一行行头
\r	换行	print("123abc\r0")	0	会将光标移动到本行行头 所以如果后续还有内容输出的话，会将本行内容完全清除，然后再打印后续内容
\t	横向制表符	print("1\t2\t3")	1 2 3	相当于按下一次tab键，即4个空格
\\	反斜线	print("\\")	\
\'	单引号	print("\'")	'
\"	双引号	print("\"")	"

列表list

  列表是Python内置的一种数据类型，是一种有序的集合，我们可以在任意时间进行添加和删除其中的元素。
  语法格式：列表名 = [元素1, 元素2, … 元素n]
  代码示例1：

	temp_list = [1, 2, "张三", "李四"]
	print(temp_list)

  运行结果：

	[1, 2, '张三', '李四']

  我们还可以通过索引的方式来访问列表的每个元素，列表的索引是从0开始的。访问列表的时候索引不要超过数组元素长度，否则会报一个IndexError的错误。
  代码示例2：

	temp_list = [1, 2, "张三", "李四"]
	print(temp_list[3])					# 访问列表中的第3个元素，也就是"李四"

  运行结果：

	李四

  如果我们需要在列表尾部追加一个元素的话，我们可以通过这种方式进行追加：列表名.append(元素)。
  删除列表指定的元素，可以使用这种方式进行删除：列表名.pop(索引)。如果不填写索引的话，默认删除的是列表中最后的一个元素。
  在列表中的指定位置插入元素，可以用这种方式进行插入：列表名.insert(索引, 元素)。
  代码示例3：

	temp_list = [1, 2, "张三", "李四"]
	temp_list.append(3)							# 在列表末尾追加一个元素3
	print(temp_list)
	temp_list.pop()								# 删除列表末尾的元素3
	temp_list.insert(2, "王五")					# 在列表索引2的位置处插入一个王五
	print(temp_list)

  运行结果：

	[1, 2, '张三', '李四', 3]
	[1, 2, '张三', '李四']
	[1, 2, '王五', '张三', '李四']

  下面列出一些其他常用的方法

常用方法	含义	例子	输出结果(备注)
列表名.index(x)	返回列表中第一个值为x的元素的索引	temp_list = [1, 2, 5, 4, 5] print(temp_list.index(5))	2
列表名.remove(x)	删除列表中第一个值为x的元素	temp_list = [1, 2, 5, 4, 5] print(temp_list)	[1,2,4,5]
列表名.reverse()	将列表中的元素排序倒转	temp_list = [1, 2, 5, 4, 5] temp_list.reverse() print(temp_list)	[5,4,5,2,1]
列表名.count(x)	统计列表中x出现的次数	temp_list = [1, 2, 5, 4, 5] print(temp_list.count(5))	2
del 列表名	删除列表	temp_list = [1, 2, 5, 4, 5] del temp_list	因为temp_list被删除了，所以后续无法再次 使用temp_list，也无法通过print打印了
del 列表名[索引]	删除列表中指定索引的元素	temp_list = [1, 2, 5, 4, 5] del temp_list[2] print(temp_list)	[1,2,4,5]
列表名.sort(key = None, reverse = False)	对列表中的元素按照一定的规则进行排序	temp_list = [1, 2, 5, 4, 5] temp_list.sort(reverse=True) print(temp_list) temp_list.sort(reverse=False) print(temp_list)	[5,5,4,2,1] [1,2,4,5,5]

元组tuple

  元组与列表类似，但是元组一旦初始化完之后就不允许修改。元组在定义的时候就必须把所有元素确定好。
  语法格式：元组名 = (元素1, 元素2, …, 元素n)
  代码示例1：

	temp_tuple_1 = (1, 2, "W")		
	temp_tuple_2 = (1, )		# 当元组只有1个元素时必须额外加一个逗号！！！
	print(temp_tuple_1)
	print(temp_tuple_2)

  运行结果：

	(1, 2, 'w')
	(1,)

  下面列出一下元组中常用的方法。

函数	作用	示例	输出结果
tuple(列表名)	将列表转换成元组	temp_list = [1, 2, "3"] tuple(temp_list) print(temp_list)	(1, 2, '3')
len(元组名)	计算元组中元素的个数	temp_tuple = (1, 2, "3") print(len(temp_tuple))	3
max(元组名)	返回元组中元素中的最大值	temp_tuple = (1, 2, 3, 100) print(max(temp_tuple))	100
min(元组名)	返回元组中元素中的最小值	temp_tuple = (1, 2, 3, 100) print(min(temp_tuple))	1

  元组中的元素也可以采用跟列表中一样方式进行访问。此外还可以通过 元组名[起始索引:结束索引] 这种方式访问一个区间内的所有元素。
  代码示例2：

	temp_tuple = (1, 2, "W", 6, 7, "A")		
	print(temp_tuple[3])
	print(temp_tuple[1:4])

  运行结果：

	6
	(2, 'w', 6)

  元组中的元素虽然无法删除，但是我们可以使用 del 元组名 将整个元组删除。元组删除之后将无法进行正常使用哦，否则会报错。
  虽然元组的元素无法修改，那是我们可以通过下面这种方式进行拼接出一个新的元组。
  代码示例3：

	temp_tuple_1 = (1, 2, "W")		
	temp_tuple_2 = (1, )		# 当元组只有1个元素时必须额外加一个逗号！！！
	temp_tuple_3 = ("李四", "张三")
	temp_tuple_4 = temp_tuple_1 + temp_tuple_2 + temp_tuple_3
	print(temp_tuple_4)

  运行结果：

	(1, 2, 'w', 1, ‘李四’, '张三')

  感兴趣的小伙伴可以试试列表是否也可以通过这种方式拼接。

字典dict

  字典是一种存储数据的格式。字典的每个元素由两部分组成，一部分是键，另一部分是值，键与值之间通过冒号相连接。字典就类似我们每个人使用的身份证一样，键就是我们的身份证号，值就是关于我们的一些个人信息，比如名字，出生年月日等等。通过身份证号，可以快速的查找到对应的那个人的信息。
  语法格式：字典名 = {键1 : 值1, 键2 : 值2, 键3 : 值3, … , 键n : 值n}
  代码示例1：

	temp_dict = {"张三" : 90， "李四" : 91, "王五" : 92}		# 键是名字，值是每个人对应的分数
	print(temp_dict["王五"])
	print(temp_dict.get("李四", 0))
	print(temp_dict.get("张三"))

  运行结果：

	92
	91
	92

  示例1讲解：

	第1行：创建了一个字典temp_dict
	第2行：通过王五这个名字快速查找字典temp_dict并返回他的分数，然后打印出来
	第3行：调用字典自带的函数get()，查找李四这个人是否存在，如果存在则返回他的分数并打印，如果不存在则打印0
	第4行：调用字典自带的函数get()，查找李四这个人是否存在，如果存在则返回他的分数并打印，如果不存在则打印None

  字典中还存在其他常用的函数，下面通过代码的方式展示。
  代码示例2：

	temp_dict = {'张三' : 90， '李四' : 91, '王五' : 92}
	print(temp_dict.keys())					# temp_dict.keys()会返回一个列表，这个列表由字典的所有键构成的信息
	print(temp_dict.values())				# temp_dict.values()会返回一个列表，这个列表由字典的所有值构成的信息
	print(temp_dict.items())				# temp_dict.items()会返回一个列表，这个列表由字典的所有键和值构成的元组
	copy_dict = temp_dict.copy()			# temp_dict.copy()会返回一个与temp_dict完全相同的字典，然后赋给copy_dict
	print(copy_dict)						# 打印字典copy_dict中的元素
	list1 = [0x41, 0x42, 0x43, 0x44]
	list2 = ['A', 'B', 'C', 'D']
	zip_dict = dict(zip(list1, list2))		# dict(zip(list1, list2))会将list1和list2合并成一个字典
	print(zip_dict)			
	zip_dict.clear()						# zip_dict.clear()会清空字典中所有的元素
	print(zip_dict)
	del copy_dict["李四"]					# del copy_dict["李四"]会删除李四那一组的元素
	print(copy_dict)
	print("李四" in copy_dict)				# "李四" in copy_dict会判断"李四"这个键在不在字典中
	print("李四" in temp_dict)				# "李四" in copy_dict会判断"李四"这个键在不在字典中
	print(len(temp_dict))					# len(temp_dict)会返回字典temp_dict中包含几个元素

  运行结果：

	dict_keys(['张三', '李四', '王五'])
	dict_values([90, 91, 92])
	dict_items([('张三', 90),('李四',91),('王五',92)])
	{'张三':90,'李四':91,'王五':92}
	{65:'A',66:'B',67:'C',68:'D'}
	{}
	{'张三':90,'王五':92}
	False
	True
	3

集合set

  集合与字典类似，但是集合不存储值。同时在集合中是没有重复的键的。
  语法格式：集合名 = {元素1, 元素2, …, 元素n}。同时也可以使用set(x)来将其他类型变量x转变成集合类型。
  代码示例1：

	temp_set_1 = {3, 2, 5, 2, 1}
	print(temp_set_1)
	temp_set_2 = set([1, 2, 5, 2, 3])
	print(temp_set_2)

  运行结果：

	{1, 2, 3, 5}
	{1, 2, 3, 5}

  示例中显示的{1, 2, 3, 5}仅仅是告诉用户这个集合里有1, 2, 3和5这4个元素，不表示集合是有序的。
  我们还可以通过 集合名.add(key) 的方式来添加一个元素key进入集合里，但如果集合本身已经含有这个元素，则添加无效。
  我们也可以通过 集合名.remove(key) 的方式来删除元素key。
  代码示例2：

	temp_set = {3, 2, 5, 2, 1}
	temp_set.add(4)
	print(temp_set)
	temp_set.remove(2)
	print(temp_set)

  运行结果：

	{1, 2, 3, 4, 5}
	{1, 3, 4, 5}

  集合与集合之间也能做像数学中集合的操作，如并集(|)、交集(&)、差集(-)和补集(^)，以及判断集合与集合之间的关系。
  代码示例3：

	temp_set_1 = {1, 2, 3, 4}
	temp_set_2 = {3, 2}
	temp_set = temp_set_1 | temp_set_2			# 求temp_set_1与temp_set_2的并集
	print(temp_set)
	temp_set = temp_set_1 & temp_set_2			# 求temp_set_1与temp_set_2的交集
	print(temp_set)
	temp_set = temp_set_1 - temp_set_2			# 求temp_set_1与temp_set_2的差集
	print(temp_set)
	temp_set = temp_set_1 ^ temp_set_2			# 求temp_set_1与temp_set_2的补集
	print(temp_set)
	print(temp_set_1 < temp_set_2)				# 判断temp_set_1和temp_set_2的子集关系
	print(temp_set_1 > temp_set_2)				# 判断temp_set_1和temp_set_2的包含关系

  运行结果：

	{1, 2, 3, 4}
	{2， 3}
	{1， 4}
	{1， 4}
	False
	True