【Python】Python基本数据类型(超详细)

前言

在上一篇文章我们简单介绍了一下Python，本章我们就开始正式学习Python，在此之前，考虑到Python环境有的小伙伴可能没有，所有我开了一个QQ群，里面有代码编辑器(PyCharm)的安装与破解使用，如果有大佬需要的话可以加群自行安装，这个群创建的目的也是方便各位讨论技术，QQ群号：455341509，共同探讨技术，认识更多的小伙伴。

tips：在开始讲基本数据类型之前，我默认了大家已经安装了Python代码编辑器与解释器，如果对安装与破解有疑问的小伙伴可以找我，在文章开始之前，因为可能有的小伙伴使用的代码编辑器五花八门，有的小伙伴喜欢使用VScode，有的大佬喜欢用命令行，所以我就跳过了对编辑器使用的教程，大家根据对应的编辑器找对应的使用教程，如果有的小伙伴也是使用pycharm也可以找我了解使用pycharm。

跟世界打招呼

每一位程序员的第一步都是跟世界打招呼，然后开始了程序员的生涯，那我们也来学习一段Python跟世界打招呼的代码吧,打开你的代码编辑器(IDEA)，新建一个hello.py的文件，输入以下代码，点击运行之后，就会显示出Hello, World，是不是很神奇，我们用了一段代码跟世界打了个招呼

text = "Hello, World"
print(text)
# Hello, World

赋值

刚才我们已经跟世界打完了招呼，但是我们还不知道我们依葫芦画瓢写的代码的作用，我们刚才定义了一个变量并且命名为text,使用了print()函数传入了变量名为text的变量，打印出了一句Hello, World，什么是函数呢，这个我们以后在函数章节再详细讨论。我们先来讲讲什么是变量，就像text = "Hello, World"简单理解就是给一个值或者数据起一个名字，这里我们是把Hello, World通过=交给了一个变量名text，所以我们也会说text是一个变量，或者是一个变量名，这个过程我们也统称为赋值，把一个值赋给一个变量，以后你要是使用到这个数据，你只需要使用这个数据的名字就可以找到这条数据，这里如果我要Hello, World这个东西，我就只需要使用它的名字text就可以拿到Hello，World。但是赋值的过程在计算机内存中开辟一个空间存储这个变量值。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符等等。

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

变量名(标识符)

变量名也称标识符，那赋值过程中，名字是可以顺便起的吗，叫什么阿猫阿狗都可以？答案是否定的，那变量名我们要怎么取呢，有什么规则要遵循。

tips： 额外拓展小知识，import是Python中导入其它模块或者第三方库的方法，暂时了解即可，后面我们再讲

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。
• 在 Python 3中，可以用中文作为变量名，非 ASCII 标识符也是允许的了，但是通常在开发中不建议这样子做，因为可能会引发一些奇奇怪怪的BUG，通常推荐全英文命名法，给一个文件命名也是同理。
• 保留字也称关键字，是Python中已经被使用或者规划使用的名字，如果我们使用他们来命名，有时候会报一些与模块相关的错误，所以我们要避免使用Python的保留字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 被认可的命名
_test = '测试'
test = '测试'
Test = '测试'
TEST = '测试'

# 会报错的命名
1 = 2
test@ = '测试'
t^est = '测试'
te)st = '测试'

# 使用保留字(关键字)也会引发命名报错
class = '测试'

# Python3中可行，但是不推荐的写法
测试 = '测试'

命名法：了解了命名的规则之后，我们来学习一下规范，优雅的命名，变量名最好是能让人见名之意，比如我叫liangzaixiaozhou，我想把liangzaixiaozhou赋值给一个变量，我会使用myName或者my_name来接收，让别人可以通过我的变量名大概知道我这个变量的大概类型。

• 驼峰命名法：除了第一个单词，其它单词首字母大写
• 下划线命名法：两个或两个单词以上使用_分开

# 驼峰命名法
myName = 'liangzaixiaozhou'
# 下划线命名法
my_name = "liangzaixiaozhou"

tips：一个好的变量名可以提升阅读者对代码的观赏性跟代码可读性

注释

在上面代码中，我们看到#字符的出现，这是符号是什么意思呢，其实#在Python中是用于单行注释，什么是注释呢，举个例子，如果我们写了一段代码，但是过了很久之后再回来看这段代码，你就会发现，这段代码变得很陌生了，这个时候就可以借助注释来帮我们记录一下这段代码的作用，也可以给阅读代码的人更加快速了解这段代码的逻辑，这里不得不讲一下程序的运行，是从上到下执行代码，而注释在程序运行中是不会被程序执行的，所以执行以下代码，只会打印出 Hello, Python! 。

• # ：是一个单行注释，作用给一行的注释，不能跨行注释
• ''' ：在这个三个单引号包裹里面的文字信息是可以跨行的注释
• """：在这个三个双引号包裹里面的文字信息是可以跨行的注释

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")

print()函数

print()函数的作用是可以帮我们打印出一段文本内容，具体什么是函数，函数的作用是什么，我们后面有详细的章节具体说明，什么是函数，以及函数的作用，我们只要知道print()函数的作用是打印文本内容，我们先依葫芦画瓢使用，但是他的作用仅仅是打印文本内容吗，答案是否定的，print()不仅仅可以打印文本内容也可以打印变量，数字，列表，字典，元组等等，尽管目前我们对有些词可能很陌生，但是没事，我们慢慢往后面看，所以我们知道print()在Python的作用是打印。

print("runoob")  # 输出字符串
# runoob
print(100)            # 输出数字
# 100

print()的骚操作

我们知道print函数的本质是打印，那打印可以玩出怎么样的骚操作呢，print是一个函数，虽然函数我们后面再讲，但是我可以跟你们先说一下函数就是把实现某些特定功能的相同的代码封装起来，可以在多处使用，减少编写过多相同的代码造成代码冗余，这里大家暂做理解一下就好，而函数是可以接受参数，完成不一样的功能。

print(*objects, sep=' ', end='\n', flush=False)

参数

• objects – 复数，表示可以一次输出单个，或者多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• flush – 如果 flush 关键字参数为 True，流会被强制刷新。

a = 1
b = 2
c = 3

print(a, b, c)
# 1 2 3

"""
sep:
同时输出多个对象的时候，会在两个对象中间用&拼接起来，当然除了&，你也可以使用任意的字符，不使用sep，就会跟上面结果一样
"""
print(a, b, c, sep='&')
# 1&2&3
"""
end:
如果你使用end，并且给他一个任意的字符，你会发现当这个print运行结束之后，会把b接到a的后面，
但是b运行完之后，c就会在新的一行输出，这是因为print的有默认的end='\n',\n在Python中是换行符，换行符就是更换一行的意思。
"""
print(a, end='?')
print(b)
print(c)
# 1?2
# 3

tips：这里又涉及到了一个知识点，Python的字符串在使用的时候可以使用一些特定的符号(转义字符)，我们留个坑，放到马上讲到的字符串内容块里面一起讲解

我们继续print函数的骚操作，使用print函数创建一个加载进度，我们使用import导入一个time时间模块，什么又是模块呢，这个我们先放在一边，后面章节再继续学习，我们本章节先学习Python基本语法使用，跟数据类型。

# 导入一个时间模块
import time

# 打印一段话
print("---RUNOOB EXAMPLE ： Loading 效果---")

# 再打印一段，使用end结尾为空，就可以阻止print函数的默认换行
print("Loading",end = "")
# 这是一段循环，目前我们先提前享受一下，至于更深入的学习，我们等待以后章节慢慢讲解
for i in range(20):
	# 打印一个点，使用end结尾为空，使用flush刷新字符流
    print(".",end = '',flush = True)
    # 设置延时0.5秒钟
    time.sleep(0.5)

Python的基本数据类型

以上我们学习了Python的一些简单语法与操作，还使用print()函数的骚操作制作了一个加载器效果，接下来我们进入重点，学习一下Python的基本数据类型，我们先了解一下Python有哪些基本数据类型。

• 字符串（String）
• 数字（Number）
• 布尔值（Bool）
• 列表（List）
• 元组（Tuple）
• 字典（Dict）
• 集合（Set）

Python3 的6个标准数据类型中：
不可变数据：String（字符串）、Number（数字）、Tuple（元组）；
可变数据：List（列表）、Dictionary（字典）、Set（集合）。
此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

数字(Number)

Python 数字数据类型用于存储数值，数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。

number1 = 10
number2 = 100

Python支持三种数字类型

• 整数(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
• 浮点数(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数((complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

运算符

什么是运算符，列如4 + 5，4和5我们称为操作数，而+称为运算符

4 + 5

Python 语言支持以下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

算术运算符

就相当于我们数学中的+ - x ÷，只不过形式可能会有细微差别

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c = a - b
print ("2 - c 的值为：", c)
 
c = a * b
print ("3 - c 的值为：", c)
 
c = a / b
print ("4 - c 的值为：", c)
 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

"""
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

"""

比较运算符

假设a=10，b=20

a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
 
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
 
# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于  b")
 
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")

"""
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
"""

赋值运算符

以下假设变量a=10，变量b=20：

a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c += a
print ("2 - c 的值为：", c)
 
c *= a
print ("3 - c 的值为：", c)
 
c /= a 
print ("4 - c 的值为：", c)
 
c = 2
c %= a
print ("5 - c 的值为：", c)
 
c **= a
print ("6 - c 的值为：", c)
 
c //= a
print ("7 - c 的值为：", c)

"""
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864
"""

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)
 
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

"""
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15

"""

逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")

"""
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false
"""

成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

"""
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
"""

身份运算符

身份运算符用于比较两个对象的存储单元

tips：id()函数是用于获取对象内存地址

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

"""
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
"""

运算符优先级

运算符也是存在优先级的，比如在同一行代码中，如果存在不同的运算符，则会根究运算符的优先级执行，如果是同级别的优先级则会从左往右执行，以下就是优先级的图表：

字符串(String)

那什么是文本呢，文本也叫字符串，什么又叫字符串呢，字符串就是一段文字信息，在Python中，被"双引号"，'单引号'，还有'''三个单引号'''，"""三个双引号"""包裹的文字信息，我们都可以称之为字符串，或者文本信息，那同样是字符串，他们之间有什么不同吗，所属类型都是字符串，但是当（'''）|（"""）没有被变量接收的时候，在文件里面就变成了注释，并且可以包裹一些很长的跨行文本，（'） |（"）直接使用是不能包裹跨行的文本的，需要使用到\转义字符续行符来帮助跨行，但是他们的本质都是字符串，所以他们的作用都是一样的。

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 还有访问字符串内的单个字符，可以使用方括号 [] 来截取字符串，我们也称之为切片，字符串的截取的语法格式如下：
变量[头下标:尾下标]

# 索引值以 0 为开始值，-1 为从末尾的开始位置。
var1 = 'Hello World!'
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
#以上实例执行结果：
# var1[0]:  H
# var1[1:5]:  ello 

这是怎么回事呢，我们来看一张图

在Python中字符串也是有对应的下标，从前面往后面就是从0开始，从后面往前就是从-1开始，我们使用str[x]就可以取出字符串对应下标的字符。

Python 字符串更新，之前我们不是了解到字符串属于不可变的吗，但是这个并不是改变字符串，只是截取字符串的一部分并与其他字段拼接，如下实例：

var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')
# 以上实例执行结果
# 已更新字符串 :  Hello Runoob!

现在我们了解了什么是字符串，以及字符串有什么形式与格式，我们穿插一下前面留下的转义字符的坑，然后再来继续讲解字符串，以及玩一下字符串的骚操作。

Python转义字符

在一段字符串中，如果字符串内有一些特殊的符号，列如：\，如果在Python里面运行，就会跟我们预期的结果有很大的不同，比如以下这段打印字符，我们的预期结果是打印一行的文字输出，但是我们也没有使用什么sep，end，为什么，打印出来的结果会是这样子呢。

print('E:\lia\n\tgzaixiaozhou')
# 预期结果： E:\lia\ngzaixi\taozhou
"""
最终结果：
E:\lia
    gzaixiaozhou
"""

因为在Python\是一个转义符号，\符号后面跟上特定的字符会有特殊的作用，我在这里只讲几个常用的字符，请看以下的表。

print("line1 \
... line2 \
... line3")
# 输出 line1 line2 line3

# 反斜杠符号	
print("\\")
# 输出 \

# 换行	
print("\n")
# 输出 
# 输出 
# 横向制表符	
print("Hello \t World!")
# 输出 Hello      World!
# 将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	
print("Hello\rWorld!")
# 输出 World!
print('google runoob taobao\r123456')
# 输出 123456 runoob taobao

所以我们这段代码会返回预期不一样的结果给我们，那如果我们要输出完整的文字呢，我们可以使用双斜杠\来阻止\的转义，但是如果有很多的转义符呢，一个一个来，就会很麻烦，所以我们有一个方法，可以对整个字符串的转义失效。只需要在字符串面前加上一个r。

print('E:\lia\n\tgzaixiaozhou')
# 预期结果： E:\lia\ngzaixi\taozhou
"""
最终结果：
E:\lia
    gzaixiaozhou
"""

print('E:\\lia\\n\\tgzaixiaozhou')
# 预期结果： E:\lia\ngzaixi\taozhou
"""
最终结果：
E:\lia\ngzaixi\taozhou
"""

print(r'E:\lia\n\tgzaixiaozhou')
# 预期结果： E:\lia\ngzaixi\taozhou
"""
最终结果：
E:\lia\ngzaixi\taozhou
"""

小插曲，我们继续来学习字符串的骚操作，字符串能有什么骚操作呢？
比如我们，现在定义了一段文本，但是文本的内容不能更换，有没有一种办法可以实现呢，就运用在我们前面讲到的知识，我们是不是可以使用字符串的拼接来完成呀，我们定义一段文本内容，把前面的Hello取出来，然后在后面拼接上新的内容，就组成了文本内容的更换。

text = 'Hello, World'

newText = text[:7] + 'Python'

print(newText)

'''
打印结果：
Hello, Python
'''

但是python是一款很优雅的语言，那肯定是有更优雅的解决方式，接下来我们就来讲讲字符串格式化。

字符串格式化三种方式：

• %格式化
• 插值格式化
• format格式化

name = 'liangzaixiaozhou'

# 插值表达式：我们在一段字符串前面加上一个f，在字符串内使用{}占位符，就可以灵活插入变量
a = f'hello {name}'

# %格式化：在字符串中插入%s，然后在字符串后面使用% 加上一个(),()放入需要的值，如果只有一个占位符，后面()内要用,结尾。
"""
%s: 插入字符串
%d：插入数字
%f：插入浮点数
"""
b = 'hello, %s' % (name,)

# format格式化：与插枝表达式差不多，都是用{}占位，只不过format是在字符串后面使用.的方式调用然后使用变量
c = 'hello,{}'.format(name)

print(a, b, c, sep='\n')

"""
最终打印结果：
hello liangzaixiaozhou
hello, liangzaixiaozhou
hello,liangzaixiaozhou
"""

数据容器

数据容器就是，可以存放数据的容器，在python中常见的数据容器就是以下几种。是 Python 中最基本的数据结构。序列是带有下标也就是我们说的索引对象，序列中的每个值我们都称之为元素，每个元素之间用,隔开,元素都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，从后面就是-1， -2，依此类推，跟字符串索引是一样的。

• 列表
• 元组
• 字典（特殊的，根据键取值，不能根据索引取值）
• 集合

列表（List）

列表都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000, True, False]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

列表的定义与操作：

我们知道列表是一个可变的基本数据类型，我们来学习一下列表的基本操作

# 最常用的列表定义方式
list1 = []

# 列表添加元素
list1.append('hello')
print(list1)
"""
list1的输出结果
['hello']
"""

# 列表删除元素
list2 = ['Google', 'Runoob', 1997, 2000]
print ("原始列表 : ", list2)
del list2[2]
print ("删除第三个元素 : ", list2)
"""
list2的输出结果
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]
"""

# 列表切片取值
list3 = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print ("list3[1]: ", list3[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list3[1:-2]: ", list3[1:-2])
"""
list3的输出结果
list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

"""

# 列表元素的更新
list4 = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list4[2])
list4[2] = 2001
print ("更新后的第三个元素为 : ", list4[2])
list5 = ['Google', 'Runoob', 'Taobao']
list5.append('Baidu')
print ("更新后的列表 : ", list5)
"""
list4，5的输出结果
第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

"""

列表常用方法

元组(Tuple)

Python 的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号 ( )，列表使用方括号 [ ]。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

# 元组的常见创建方式与注意细节
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   #  不需要括号也可以
# 如果是一个元素，不使用,的话,就会被当成一个元素，而不是元组
tup4 = (50)
"""
tup4 = 50
"""
tup5 = (50,)
"""
tup5 = (50)
"""

# 元组取值跟列表一样
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
"""
tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)
"""

# 元组更新，元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
"""
(12, 34.56, 'abc', 'xyz')
"""

# 删除元组，元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
"""
删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined
"""

元组常用方法

字典(Dict)

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。一个简单的字典实例格式如下所示：

# 字典格式
d = {key1 : value1, key2 : value2, key3 : value3 }

# 列如：
tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
# 或者
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

# 字典的常用创建
emptyDict = {}
emptyDict = dict()

# 获取键的值 
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
"""
tinydict['Name']:  Runoob
tinydict['Age']:  7
"""
# 如果字典中没有对应的键会报错
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])
"""
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'
"""

# 修改字典,向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
"""
tinydict['Age']:  8
tinydict['School']:  菜鸟教程
"""

# 删除字典元素,能删单一的元素也能清空字典，清空只需一项操作。显式删除一个字典用del命令，如下实例：
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
"""
Traceback (most recent call last):
  File "/runoob-test/test.py", line 9, in <module>
    print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined
"""

# 字典键的特性,字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': 'liangzaixiaozhou'}
print ("tinydict['Name']: ", tinydict['Name'])
"""
tinydict['Name']:  liangzaixiaozhou
"""
# 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
tinydict = {['Name']: 'Runoob', 'Age': 7}
print ("tinydict['Name']: ", tinydict['Name'])
"""
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
"""

字典常用方法

集合(Set)

集合（set）是一个无序的不重复元素序列。集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

# 集合的常用创建
set1 = {1, 2, 3, 4}            # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7])      # 使用 set() 函数从列表创建集合
# 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# 集合添加元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)
"""
{'Taobao', 'Facebook', 'Google', 'Runoob'}
"""

# 集合删除元素
thisset1 = set(("Google", "Runoob", "Taobao"))
thisset1.remove("Taobao")
print(thisset1)
"""
{'Google', 'Runoob'}
"""
thisset1.remove("Facebook")   # 不存在会发生错误
"""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
"""
# 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
thisset2 = set(("Google", "Runoob", "Taobao"))
thisset2.discard("Facebook")  # 不存在不会发生错误
print(thisset2)
"""
{'Taobao', 'Google', 'Runoob'}
"""

# 我们也可以设置随机删除集合中的一个元素，语法格式如下：
thisset3 = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset3.pop()
print(x)

集合常用方法

知识点补充：

Python中万物皆对象，凡是对象就会有对象的属性跟方法，方法的调用就是通过对象.方法的方式，列如：list.append()

结言：

本次python基本数据类型章就结束了，如果有知识点讲的不对或者遗漏，大家也可以提出来，小弟会虚心受教，各位大佬们要是有什么疑问，可以在评论区讨论留言，也可以加入上方基础QQ群，如果我看到我会尽我的知识点解答，谢谢各位大佬观看，下一章《Python流程控制》正在筹备中，敬请期待。。。

标签：Python,数据类型,列表,运算符,字符串,详细,print,tinydict
From： https://blog.csdn.net/liangzaixiaozhou/article/details/136936788