Python基础知识语法归纳总结（数据类型-1）

 

Python基础知识&语法归纳总结（数据类型）  

一、Python基本数据类型

  尤其注意，Python中的变量不需要特定的去声明，每个变量在使用前都必须对其进行赋值，它没有类型，我们所说的“类型”是变量所指的内存中对象的类型。
  等号（=）用来给变量赋值。
  等号（=）左边是一个变量名，而右边是一个存储在变量中的值。

1.1 程序演示

  如下面的程序：

a = 30
b = 30.0
c = '小明'
d = True
e = ['小米', '小王', 'Alice', 'Fock']
f = (a, b, c, d)
g = {'1', '2', '3', '4', '5', '6'}
h = {'name': '小米','age': 20,'like': 'Dog',
}print(f"{a},它的数据类型是：{type(a)}。")
print(f"{b}，它的数据类型为{type(b)}。")
print(f"{c}，它的数据类型为{type(c)}。")
print(f"{d}，它的数据类型为{type(d)}。")
print(f"{e}，它的数据类型为{type(e)}。")
print(f"{f}，它的数据类型为{type(f)}。")
print(f"{g}，它的数据类型为{type(g)}。")
print(f"{h}，它的数据类型为{type(h)}。")

  输出结果：

30,它的数据类型是：<class ‘int’>。
30.0，它的数据类型为<class ‘float’>。
小明，它的数据类型为<class ‘str’>。
True，它的数据类型为<class ‘bool’>。
[‘小米’, ‘小王’, ‘Alice’, ‘Fock’]，它的数据类型为<class ‘list’>。
(30, 30.0, ‘小明’, True)，它的数据类型为<class ‘tuple’>。
{‘2’, ‘3’, ‘5’, ‘1’, ‘4’, ‘6’}，它的数据类型为<class ‘set’>。
{‘name’: ‘小米’, ‘age’: 20, ‘like’: ‘Dog’}，它的数据类型为<class ‘dict’>。

  下面我们来一一解释这些数据类型。
 

1.2 标准数据类型

  Python中常见的数据类型有：

• Number（数值类型）
• String（字符串类型）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

 
  Python的六大数据类型主要可分为两类：

• 不可变数据：Number（数值类型）、String（字符串）、Tuple（元组）
• 可变数据：List（列表）、Dictionary（字典）、Set（集合）
  除此之外，还有一些高级的数据类型，比如字节数组类型（bytes）。
   

1.3 Number（数值类型）

  Python支持的数值类型有：int、float、bool、complex（复数） —— 这些数值类型，主要指Python3；
  那么，还有一种Python2中的long型；
  Python内置的函数type()函数可以用来查询变量所指的对象数据类型；
  除此之外，还可以使用isinstance来判断，如下：

a = 30
print(isinstance(a,float))
# 输出结果：False

  isinstance和type的区别：

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

class A:"""书写一个父类"""passclass B(A):"""书写一个子类来继承父类"""passprint(isinstance(A(), A))  # True
print(type(A()) == A)      # True
print(isinstance(B(), A))  # True
print(type(B()) == A)      # False

  特别注意：在之前的程序中，可能会出现True和False数字加减的情况，因为True == 1、False == 0会返回True，但可以通过isinstance()来判断类型。

print(isinstance(bool, int))  # False
print(True + 1)               # 2
print(False + 1)              # 1
print(1 is True)              # False
print(0 is False)             # False

使用print(1 is True) 、print(0 is False) 程序出现了一个警告，如下图：

  为什么会出现SyntaxWarning？
  Python检测到你在用is比较一个整型数值，就给你报了一个语法警告，这通常也就是代码错误（因为is比较的是身份，而不是值），而Python也给出了一个建议，Python建议你使用==来代替is，这样效果会好很多。
 

• 1、Python可以同时为多个变量赋值，如a,b = 1,2；
• 2、一个变量可以通过赋值指向不同类型的对象；
• 3、数值的除法包含来个运算符：/返回一个浮点数，//返回一个整数；
• 4、在混合计算时，Python会把整型转换成为浮点数。
   
  数值类型实例：

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3e+18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

 

1.4 String（字符串）

  Python中的字符串用单引号'或者使用"括起来，同时使用反斜杠\转义特殊字符。
  字符串截取的语法格式如下：

加号 + 是字符串的连接，星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

strings = '小明你是猪吗？'
print(f"打印字符串：{strings}。")
print(f"打印第一个到倒数第二个字符（不包含倒数第一个字符）：{strings[0: -1]}")
print(f"打印第一个字符：{strings[0]}")
print(f"打印第三个到第五个字符（不包含第五个字符）：{strings[2:5]}")
print(f"打印字符串从第三个开始到最后一个字符：{strings[2:]}")
print(f"打印三次字符串：{strings * 3}")
print(strings + "不，你是蠢猪！！")

  运行结果：

打印字符串：小明你是猪吗？。
打印第一个到倒数第二个字符（不包含倒数第一个字符）：小明你是猪吗
打印第一个字符：小
打印第三个到第五个字符（不包含第五个字符）：你是猪
打印字符串从第三个开始到最后一个字符：你是猪吗？
打印三次字符串：小明你是猪吗？小明你是猪吗？小明你是猪吗？
小明你是猪吗？不，你是蠢猪！！

 
  Python使用反斜杠\n转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面加一个r，表示原始字符串，如下：

print("你是\n猪")    
print(r'你是\n猪')

  输出结果：

你是
猪
你是\n猪

  特别注意：Python字符串不能被改变，向一个索引位置赋值，会报错误，报错如下：

注意：

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

1.5 bool（布尔类型）

  布尔类型即 True或 False。
  在 Python 中，True 和 False 都是关键字，表示布尔值。
  布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。
  布尔类型特点：

• 布尔类型只有两个值：True 和 False。
• bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。
• 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
• 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
• 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True会被转换成 1，False 会被转换成 0。
• 可以使用 bool() 函数将其他类型的值转换为布尔值。以下值在转换为布尔值时为 False：None、False、零 (0、0.0、0j)、空序列（如 ''、()、[]）和空映射（如 {}）。其他所有值转换为布尔值时均为 True。

  

"""bool（布尔类型）实例"""
a = True
b = False
print(a + b)
print(a - b)
print(a * b)
# 进行判断，让程序不因为报错而终止运行，在这里添加了一段异常处理方式，进而让程序继续往下执行
try:print(a / b)
except ZeroDivisionError:print("你是怎么想的，竟然用（零）做除数！！！")
# 看一下变量a、b的数据类型
print(type(a))
print(type(b))
# bool()函数转换
print(bool(a))
print(bool(b))
print(bool(54))
print(bool([]))
print(bool({}))
print(bool('王'))
print(bool(3*5))
# bool判断数值运算
print(4 > 5)
print(4 > -30)
# bool在if- else中的作用
if True:print("你是对的，我相信你！！")
if not False:print("我依然相信你，不用怕！！")
x = 100
if x < 50:print(f"这是{x}。")
else:print("哇哦，还行！")

  运行结果：

1
1
0
你是怎么想的，竟然用（零）做除数！！！
<class ‘bool’>
<class ‘bool’>
True
False
True
False
False
True
True
False
True
你是对的，我相信你！！
我依然相信你，不用怕！！
哇哦，还行！

 
  注意: 在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。
 
 

1.6 List（列表）

  List（列表）是Python中使用最频繁的数据类型。
  列表可以完成大多数集合类的数据结构，列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表（也就是所谓的嵌套）。列表是写在方括号[]之间，用逗号,隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
  列表截取的语法格式如下：

变量[头下标 : 尾下标]

  索引值以0为开始值，-1为末尾的开始位置。

  同样的，加号+是列表连接运算符，星号*是重复操作：
 

  小试牛刀：将一个色子掷7000次，统计每种点数出现的次数；

import randoma1 = 0
a2 = 0
a3 = 0
a4 = 0
a5 = 0
a6 = 0
for i in range(7000):face = random.randrange(1, 7)if face == 1:a1 += 1elif face == 2:a2 += 1elif face == 3:a3 += 1elif face == 4:a4 += 1elif face == 5:a5 += 1elif face == 6:a6 += 1else:print("你越界了！！")pass
# 打印出现的次数
print(f"点数1出现的次数：{a1}。")
print(f"点数2出现的次数：{a2}。")
print(f"点数3出现的次数：{a3}。")
print(f"点数4出现的次数：{a4}。")
print(f"点数5出现的次数：{a5}。")
print(f"点数6出现的次数：{a6}。")

  运行结果：

点数1出现的次数：1151。
点数2出现的次数：1152。
点数3出现的次数：1169。
点数4出现的次数：1183。
点数5出现的次数：1140。
点数6出现的次数：1205。

  上面的代码，看起来，最后的结果也确实实现出来了，但是分支用的太多，麻烦、冗余。我们有一种更好的方法来优化上面的代码，也就是用这里的列表来实现。在Python中，我们可以使用容器型变量来保存和操作多个数据，也就是这里的列表（List）：
 
  Python中的列表，它的长度和列表元素都是可以改变的。
 
 
  注意：

• 访问列表中的值：它与字符串的索引是一样的，即从0开始，第二个索引是1，依此类推；而列表中的最后一个字符串的索引为-1，往前一个是-2，也是依此类推的，如下图：
  
• 使用索引进行截取列表[]，如下图：
  
• 更新列表：我们可以对列表中的数据项进行修改或者更新，也可以使用append()来添加列表项，如下所示：

"""更新列表"""
lists = ['Google', 'Alice', 'cn.bing.com', 'www.baidu.com', 'www.bilibili.com', 'Stock', '小明']
# 打印这个列表
print(f"这个列表数据项为：{lists}。")
# 打印最后一个列表数据项
print(f"列表lists中，最后一个数据项为{lists[-1]}。")
# 替换列表中，最后一个元素 '小明' 将其替换为 'Yuer'
lists[-1] = 'Yuer'
# 打印替换后的最后一个元素
print(f"列表lists替换后的，最后一个数据项为{lists[-1]}。")
# 截取列表 listss = list[2 : 5]
strList = lists[2:len(lists) - 3]
# 打印出截取到的列表
print(f"截取到的列表数据项为：{strList}。")
# 向列表中添加一个元素 '大明'
lists.append('大明')
# 输出添加的列表数据项
print(f"添加的列表数据项为：{lists[-1]}")
print(f"经过更新后，这个列表中的数据项为{lists}")

  运行结果：

这个列表数据项为：[‘Google’, ‘Alice’, ‘cn.bing.com’, ‘www.baidu.com’, ‘www.bilibili.com’, ‘Stock’, ‘小明’]。
列表lists中，最后一个数据项为小明。
列表lists替换后的，最后一个数据项为Yuer。
截取到的列表数据项为：[‘cn.bing.com’, ‘www.baidu.com’]。
添加的列表数据项为：大明
经过更新后，这个列表中的数据项为[‘Google’, ‘Alice’, ‘cn.bing.com’, ‘www.baidu.com’, ‘www.bilibili.com’, ‘Stock’, ‘Yuer’, ‘大明’]

• 列表的运算：我们可以使用+运算符来实现两个列表的拼接，拼接运算会将两个列表中的元素连接在一起，放到一个列表中，同理，使用*号也是同样的效果，如下：

"""列表的运算 —— +号"""
aa = [1, 11, 12, 13, 14, 15]
bb = [3, 11, 45, 67, 98, 12]
cc = ['Python', 'Java', 'C++', 'JavaScript']
# 拼接运算
dd = aa + bb + cc
print(f"拼接后的列表为：{dd}。")"""使用 * 号代码重复运算"""
ee = cc * 2
print(f"使用*号的运算结果：{ee}")

  运算结果：

拼接后的列表为：[1, 11, 12, 13, 14, 15, 3, 11, 45, 67, 98, 12, ‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]。

使用*号的运算结果：[‘Python’, ‘Java’, ‘C++’, ‘JavaScript’, ‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]

• 使用列表切片来提取子列表数据项：列表切片是一种非常强大的功能，它运行你从一个列表中提取一部分元素进而新成新的子列表。切片操作使用方括号[]和冒号:来指定起始索引、结束索引以及步长。

"""列表的运算 —— +号"""
aa = [1, 11, 12, 13, 14, 15]
bb = [3, 11, 45, 67, 98, 12]
cc = ['Python', 'Java', 'C++', 'JavaScript']
# 拼接运算
dd = aa + bb + cc
print(f"拼接后的列表为：{dd}。")"""使用 * 号代码重复运算"""
ee = cc * 2
print(f"使用*号的运算结果：{ee}")"""切片提取列表数据项形成新的子列表"""
# 提取列表dd中的数据项
dd1 = dd[0: len(dd)-3: 3]
# 输出使用切片后得到的子列表
print(f"使用切片后获取到的列表为：{dd1}。")

  输出结果：

拼接后的列表为：[1, 11, 12, 13, 14, 15, 3, 11, 45, 67, 98, 12, ‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]。
使用*号的运算结果：[‘Python’, ‘Java’, ‘C++’, ‘JavaScript’, ‘Python’, ‘Java’, ‘C++’, ‘JavaScript’]
使用切片后获取到的列表为：[1, 13, 3, 67, ‘Python’]。

  语法：

  切片运算是形如[start:end:stride]的运算符，其中start代表访问列表元素的起始位置，end代表访问列表元素的终止位置（终止位置的元素无法访问），而stride则代表了跨度，简单的说就是位置的增量，比如我们访问的第一个元素在start位置，那么第二个元素就在start + stride位置，当然start + stride要小于end。

  如果start值等于0，那么在使用切片运算符时可以将其省略；如果end值等于N，N代表列表元素的个数，那么在使用切片运算符时可以将其省略；如果stride值等于1，那么在使用切片运算符时也可以将其省略。

• 通过切片来更改列表数据项：如下

# 操作切片来修改列表中的数据项
# 操作切片来修改列表中的数据项
dd1 = [1, 13, 3, 67, 'Python']
dd1[1: 3: 1] = ['C#', 'C++']
print(f"输出经过使用切片修改后的列表数据项：{dd1}。")

  输出结果：
输出经过使用切片修改后的列表数据项：[1, ‘C#’, ‘C++’, 67, ‘Python’]。

• 列表之间还可以做关系运算：我们可以比较两个列表是否相等，也可以给两个列表比较大小，如下：

"""列表做关系运算"""
a = [1, 3, 7, 89]
b = [4, 9, 20]
print(a == b)   #False
print(a != b)   #True
print(a > b)    #False

  上面的a和b对应的元素完全不相等，索引进行==运算的结果为False；进行!=运算后的结果为True；而进行>运算的结果为False。大小关系通常比较的是第一个元素，所以才会出现，进行a > b的运算后，结果为False。
 

• 元素的遍历：在Python中，for循环是一种常见的遍历列表的方式，通过for循环，我们可以一次访问列表中的每一个元素，并对其进行操作。

c = ['Python', 'Java', 'C++', 'JavaScript']
for i in c:print(i)

  代码解析：
  1、c = ['Python', 'Java', 'C++', 'JavaScript']：定义了一个包含三个元素的列表c；
  2、for i in c:：使用for循环遍历列表c，每次循环将列表中的一个数据项赋值给变量i。
  3、print(i)，在每次循环中，打印当前i的值；

  输出结果：

Python
Java
C++
JavaScript

  上面的掷色子就可以优化了，优化如下：

import randomcount = [0] * 6
print(count)
# 循环7000次
for a in range(7000):# face用来记录，出现1到7出现的点数face = random.randrange(1, 7)# 利用索引每次循环就对对应的点数加一，即将循环后的索引对应的列表数据项进行更新count[face - 1] += 1
# 再对1到7生成的点数进行循环，即获取列表count中的列表数据项
for face in range(1, 7):print(f"点数{face}出现的次数为{count[face - 1]}。")

  运行结果：

点数1出现的次数为1210。
点数2出现的次数为1175。
点数3出现的次数为1160。
点数4出现的次数为1161。
点数5出现的次数为1179。
点数6出现的次数为1115。