一、数值类型
1   整数类型
与数学中的整数含义相同，无取值范围；
整数包括二进制、八进制、十进制、十六进制等4种表示形式；
二进制：以0b或0B开头：0b1101,-0B10;
八进制：以0o或0O开头：0o456,-0O789;
十进制：123，-321,0；
十六进制：以0x或0X开头：0x1A,-0X2B。
如：0b1010 = 0o12 = 10 = 0xa
代码实例1

a = 10
print(a, type(a ))

运行结果如下：

2   浮点数类型
与数学中的实数含义相同，带有小数及小数的数字，存在取值范围；
浮点数包括常规方法和科学计数法2种方式表示；
科学计数法使用字母e或E作为幂的符号，以10位基数，格式：<a>e<b> 表示 a*；
如：0.0043 = 4.3e-3     ；  98000000.0 = 9.8E7
不确定尾数问题：浮点数直接运算，可能产生不确定尾数。不确定尾数问题来源于浮点数在计算机中表示不精确的实际情况，广泛存在于编程语言中。可以使用round()辅助浮点数运算，消除不确定尾数。
代码实例1

print(0.1 + 0.2)   # 不确定尾数问题
 
round(x , b)：对x四舍五入，d是小数截取位数
 
print(round(0.1 + 0.2,1)    # 消除不确定尾数

运行结果如下：

代码实例2

f = 3.14
print(f,type(f))

运行结果如下：

3   复数类型
与数学中的复数概念相同，定义 j = ，复数表示为 a+bj；

z = a+bj，a是实部，b是虚部，a和b都是浮点数；
z.real获得z的实部，z.imag获得z的虚部。
代码实例

z = 2 + 3j
print(z, type(z))

运行结果如下：

二、字符串类型
        我们要知道 1 和 "1"是两种不同的数据类型，前者是一个数字，可以进行加减乘除的操作，而后者则是个单纯的字符串，也就是常说的文本内容。字符串的一个特点就是在它的两旁有单引号或者双引号。

1   字符串类型

（1）字符串定义
字符串：由0个或多个字符组成的有序字符序列，由一对单引号(' ')或一对双引号(" ")表示，可对字符进行索引，用序号进行访问。
表示方法：由一对单引号或双引号表示，仅表示单行字符串；由一对三单引号或三双引号表示，可表示多行字符串。
（2）字符串的序号

代码实例

（3）字符串的使用
使用[ ] 获取字符串中一个或多个字符。
字符串索引：s[N] 通过序号获取单个字符。
字符串切片：s[M:N] 获取M到N(不含)子串，使用[M: N :K]根据步长对字符串切片，使用[::-1]对字符串进行逆序。其中，M缺失表示至开头，N缺失表示至结尾。
代码实例

s1 = "中华人民共和国合同法"
print(s1[2:7])

运行结果如下：

（4）字符串处理函数
函数及使用    描述
len(x)    长度，返回字符串x的长度
str(x)    任意类型x所对应的字符串形式
hex(x)或oct(x)    整数x的十六进制或八进制小写形式字符串
chr(x)    x为Unicode编码，返回其对应的字符
ord(x)    x为字符，返回其对应的Unicode编码
代码实例

b = "abcdef"
print(len(b))
a = 56
print(a,bin(a))
print(a,hex(a))
print(a,oct(a))
# 编码
bytes_result = "中华人民共和国合同法".encode(encoding="gbk")
print(type(bytes_result), bytes_result)
str_result = bytes_result.decode(encoding="gbk")
print(type(str_result), str_result)

代码运行结果如下：

（5）字符串处理方法
方法及使用    描述
str.lower()或str.upper()    返回字符串的副本，全部字符小写/大写
str.split(sep=None)    返回一个列表，由str根据sep被分割的部分组成
str.count(sub)    返回子串sub在str中出现的次数
str.replace(old,new)    返回字符串str的副本，所有old子串被替换为new
str.center(width[,fillchar])    字符串str根据宽度width居中，fillchar可选
str.strip(chars)    从str中去掉在其左侧和右侧chars中列出的字符
str.join(iter)    在iter变量除最后元素外每个元素后增加一个str
代码实例

print("中华人民共和国合同法".index("共和国"))
print("中华人民共和国合同法共和国".rindex("共和国"))
print("中华人民共和国合同法".find("共和国0"))
print("中华人民共和国合同法共和国".rfind("共和国0"))
print("====================")
print("中华人民共和国合同法共和国".count("共和国"))
print("====================")
print("aBcd efG".capitalize())
print("aBcd".upper())
print("aBcd".lower())
print("aBcd efG".swapcase())
print("aBcd efG".title())
print("====================")
print("醒醒".center(20, "+"))
print("醒醒".ljust(20, "+"))
print("醒醒".rjust(20, "+"))
print("醒醒".zfill(20))
print("====================")

print("中华人民共和国合同法共和国".endswith("共和国"))
print("中华人民共和国合同法共和国".startswith("中华"))

print("====================")

# 编码
bytes_result = "中华人民共和国合同法".encode(encoding="gbk")
print(type(bytes_result), bytes_result)
str_result = bytes_result.decode(encoding="gbk")
print(type(str_result), str_result)

print("====================")

r = "中华人民共和国合同法".split("共和国")
print(type(r), r)

print("++".join(r))

print("====================")

print("中华人民共和国合同法".replace("合同法", "刑法"))
print("====================")
print("".isalpha())

s1 ="中华人民共和国合同法"
# print(s1.startswith("合", 7, 9))
#
# s2 = "sefsfefweimn sdzcvuhsefjkxcu"
# s3 = s2.capitalize()
# print(s3)

运行结果如下：

三、组合类型

1. 列表类型

（1）列表的定义

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

（2）列表的特点

• 序列类型的一种，元素间的有序组合，类型不限，创建后可以随时被修改
• 列表使用中括号[]表示，元素间用逗号分隔，括号不可省略
• 列表可以将多个数据有序地组织在一起，更方便调用
• 如：ls = ["cat", "tiger", 1024]

 (3)列表的操作方法

 Python包含以下函数:

Python包含以下方法:

以下是对上面的方法或函数的详细解释。

一、函数

1. len(list)
   • 功能：返回列表中元素的个数。
   • 示例：

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出: 5

1. max(list)
   • 功能：返回列表中的最大值。
   • 示例：

numbers = [2, 8, 1, 9, 5]
max_value = max(numbers)
print(max_value)  # 输出: 9

1. min(list)
   • 功能：返回列表中的最小值。
   • 示例：

numbers = [2, 8, 1, 9, 5]
min_value = min(numbers)
print(min_value)  # 输出: 1

1. list(seq)
   • 功能：将元组或其他可迭代对象转换为列表。
   • 示例：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出: [1, 2, 3]

二、方法

1. list.append(obj)
   • 功能：在列表末尾添加新的对象。
   • 示例：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

1. list.count(obj)
   • 功能：统计某个元素在列表中出现的次数。
   • 示例：

my_list = [1, 2, 2, 3, 2]
count = my_list.count(2)
print(count)  # 输出: 3

1. list.extend(seq)
   • 功能：在列表末尾一次性追加另一个序列中的多个值，从而扩展原来的列表。
   • 示例：

my_list = [1, 2, 3]
another_list = [4, 5, 6]
my_list.extend(another_list)
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

1. list.index(obj)
   • 功能：从列表中找出某个值第一个匹配项的索引位置。
   • 示例：

my_list = [10, 20, 30, 20]
index = my_list.index(20)
print(index)  # 输出: 1

1. list.insert(index, obj)
   • 功能：将对象插入到列表的指定索引位置。
   • 示例：

my_list = [1, 2, 3]
my_list.insert(1, 4)
print(my_list)  # 输出: [1, 4, 2, 3]

1. list.pop([index=-1])
   • 功能：移除列表中的一个元素（默认移除最后一个元素），并且返回该元素的值。
   • 示例：

my_list = [1, 2, 3]
removed_item = my_list.pop()
print(removed_item)  # 输出: 3
print(my_list)  # 输出: [1, 2]

1. list.remove(obj)
   • 功能：移除列表中某个值的第一个匹配项。
   • 示例：

my_list = [1, 2, 2, 3]
my_list.remove(2)
print(my_list)  # 输出: [1, 2, 3]

1. list.reverse()
   • 功能：反向列表中元素的顺序。
   • 示例：

my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # 输出: [3, 2, 1]

1. list.sort( key=None, reverse=False)
   • 功能：对原列表进行排序。如果 reverse=True，则降序排序；否则升序排序。
   • 示例：

my_list = [5, 1, 3, 2]
my_list.sort()
print(my_list)  # 输出: [1, 2, 3, 5]

my_list.sort(reverse=True)
print(my_list)  # 输出: [5, 3, 2, 1]

1. list.clear()
   • 功能：清空列表中的所有元素。
   • 示例：

my_list = [1, 2, 3]
my_list.clear()
print(my_list)  # 输出: []

1. list.copy()
   • 功能：复制列表，生成一个新的列表，与原列表内容相同但独立。
   • 示例：

my_list = [1, 2, 3]
new_list = my_list.copy()
print(new_list)  # 输出: [1, 2, 3]

2、元组类型

（1）元组的定义

元组是一种有序且不可变的元素集合。它就像是一个被封印的宝箱，一旦装满宝贝，就无法再更改里面的东西。

（2）元组的特点

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

（3）元组的操作方法

Python元组包含了以下内置函数

>>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3
>>> 

>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>> 

>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>>

>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

3、字典类型

（1）字典的定义

字典可以使用花括号 {} 来创建，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔,dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。

（2）字典的特点

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

 字典类型是键值对的集合，反映了数据之间的映射关系

 字典使用大括号{}表示，键值间用冒号分隔，键值对间用逗号分隔

 映射是一种键（索引）和值（数据）的对应（3）字典的操作方法4、集合类型（1）集合的定义

（3）字典的操作方法

Python字典包含了以下内置函数：

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(tinydict)
3

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(tinydict)
<class 'dict'>

Python字典包含了以下内置方法：

以下是对上面方法的详细介绍：

内置函数

1. len(dict)

   len() 函数用于获取字典中键的数量。通过传入字典作为参数，它会返回字典中键值对的总数。例如对于 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} ，使用 len(tinydict) 可以得到 3。

2. str(dict)

   str() 函数将字典转换为可打印的字符串形式。它会以字符串的形式展示字典的键值对内容。如您给出的示例，对于字典 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} ，使用 str(tinydict) 得到 "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" 。

3. type(variable)

   type() 函数用于确定传入变量的数据类型。当传入的变量是字典时，它会返回 <class 'dict'> ，用于判断变量的类型是否为字典。

内置方法

dict.clear()

此方法用于清空字典中的所有键值对，使字典变为一个空字典。

示例：

   my_dict = {'a': 1, 'b': 2}
   my_dict.clear()
   print(my_dict)  

输出： {}

dict.copy()

该方法创建并返回一个字典的浅复制。浅复制意味着新字典中的键值对与原字典相同，但如果字典的值是可变对象（如列表、字典等），则新字典和原字典中的这些可变对象会指向相同的内存地址。

示例：

   original_dict = {'a': [1, 2, 3], 'b': 2}
   copied_dict = original_dict.copy()
   original_dict['a'].append(4)
   print(copied_dict)  

输出： {'a': [1, 2, 3, 4], 'b': 2}

dict.fromkeys()

它可以根据给定的序列（如列表、元组等）创建一个新的字典，其中序列中的元素作为新字典的键，并且可以指定所有键对应的初始值（如果没有指定，默认初始值为 None ）。

示例：

   keys = ['a', 'b', 'c']
   new_dict = dict.fromkeys(keys, 0)
   print(new_dict)  

输出： {'a': 0, 'b': 0, 'c': 0}

dict.get(key, default=None)

通过指定的键来获取对应的值，如果指定的键不存在于字典中，将返回您设置的默认值（默认情况下为 None ）。

示例：

   my_dict = {'a': 1, 'b': 2}
   print(my_dict.get('a'))  
   print(my_dict.get('c', -1)) 

输出： 1 -1

key in dict

这是一个用于检查指定的键是否存在于字典中的操作符。如果键存在，返回 True；否则，返回 False 。

示例：

   my_dict = {'a': 1, 'b': 2}
   print('a' in my_dict)  
   print('c' in my_dict) 

输出： True False

dict.items()

该方法返回一个包含字典中所有键值对的视图对象，您可以对这个视图对象进行迭代操作。

示例：

   my_dict = {'a': 1, 'b': 2}
   for key, value in my_dict.items():
       print(f'Key: {key}, Value: {value}')

1. dict.keys()

   返回一个包含字典所有键的视图对象。

   示例：

   my_dict = {'a': 1, 'b': 2}
   for key in my_dict.keys():
       print(key)

1. dict.setdefault(key, default=None)

   如果指定的键存在于字典中，该方法返回对应的值；如果键不存在，它会将键和您指定的默认值添加到字典中，并返回该默认值。

   示例：

   my_dict = {'a': 1, 'b': 2}
   print(my_dict.setdefault('a', 0))  
   print(my_dict.setdefault('c', 3)) 
   print(my_dict) 

输出： 1 3 {'a': 1, 'b': 2, 'c': 3}

1. dict.update(dict2)

   将另一个字典 dict2 的键值对更新添加到当前字典中，如果存在相同的键，对应的值会被 dict2 中的值覆盖。

   示例：

   my_dict = {'a': 1, 'b': 2}
   new_dict = {'b': 3, 'c': 4}
   my_dict.update(new_dict)
   print(my_dict) 

输出： {'a': 1, 'b': 3, 'c': 4}

1. dict.values()

返回一个包含字典所有值的视图对象。

示例：

   my_dict = {'a': 1, 'b': 2}
   for value in my_dict.values():
       print(value)

1. pop(key[,default])

根据指定的键删除并返回对应的键值对的值，如果键不存在且指定了默认值，返回默认值；如果键不存在且没有指定默认值，会引发 KeyError 错误。

示例：

   my_dict = {'a': 1, 'b': 2}
   print(my_dict.pop('a'))  

输出： 1

1. popitem()

随机删除并返回字典中的一个键值对，如果字典为空，会引发 KeyError 错误。

   my_dict = {'a': 1, 'b': 2}
   print(my_dict.popitem())  

输出： 一个键值对，例如 ('a', 1) 或 ('b', 2)

4、集合类型

（1）集合的定义

集合：多个元素的无序组合，使用大括号{}表示，元素间用逗号分隔，建立非集合使用{}或set()函数。

基本功能：集合的两个基本功能分别是去重和成员测试。

（2）集合的特点

无序性
集合中的元素是无序存储的，这意味着您不能依赖特定的顺序来访问或操作元素。

唯一性
集合不允许重复的元素存在。

可变性
集合是可变的，您可以添加或删除元素。

（3）集合的操作方法

方法的简单介绍：

以下是对这些集合方法的更详细解释：

add() 方法：
这个方法用于向集合中添加一个新元素。集合的特点是不允许重复元素，所以如果添加的元素已经存在于集合中，不会产生任何效果。例如：

s = {1, 2}
s.add(3)
print(s)  # 输出: {1, 2, 3}
s.add(2)
print(s)  # 输出: {1, 2, 3}  因为 2 已存在，所以没有添加

clear() 方法：
此方法会清空集合中的所有元素，将集合变为一个空集合。

s = {1, 2, 3}
s.clear()
print(s)  # 输出: set()

copy() 方法：
它创建并返回一个集合的独立副本。这意味着对原始集合的修改不会影响副本，反之亦然。

s1 = {1, 2, 3}
s2 = s1.copy()
s1.add(4)
print(s1)  # 输出: {1, 2, 3, 4}
print(s2)  # 输出: {1, 2, 3}

difference() 方法：
返回一个新的集合，其中包含调用集合中存在但在指定的一个或多个集合中不存在的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
print(s1.difference(s2))  # 输出: {1, 2}

difference_update() 方法：
直接在原始集合上进行修改，移除在指定集合中也存在的元素。

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5}
s1.difference_update(s2)
print(s1)  # 输出: {1, 2}

discard() 方法：
删除集合中指定的元素，如果元素不存在，不会引发错误。

s = {1, 2, 3}
s.discard(2)
print(s)  # 输出: {1, 3}
s.discard(5)  # 不会报错

intersection() 方法：
返回一个新的集合，其中包含两个或多个集合中共同存在的元素。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1.intersection(s2))  # 输出: {2, 3}

intersection_update() 方法：
直接在原始集合上修改，使其只保留与指定集合的交集。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1.intersection_update(s2)
print(s1)  # 输出: {2, 3}

isdisjoint() 方法：
判断两个集合是否没有共同的元素。如果没有共同元素，返回 True ；否则返回 False 。

s1 = {1, 2}
s2 = {3, 4}
print(s1.isdisjoint(s2))  # 输出: True
s3 = {2, 5}
print(s1.isdisjoint(s3))  # 输出: False

issubset() 方法：
判断一个集合是否为另一个集合的子集。如果指定集合的所有元素都在参数集合中，则返回 True ；否则返回 False 。

s1 = {1, 2}
s2 = {1, 2, 3}
print(s1.issubset(s2))  # 输出: True

issuperset() 方法：
判断一个集合是否是另一个集合的超集。如果参数集合的所有元素都在指定集合中，则返回 True ；否则返回 False 。

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1.issuperset(s2))  # 输出: True

pop() 方法：
随机移除并返回集合中的一个元素。如果集合为空，会引发 KeyError 。

s = {1, 2, 3}
print(s.pop())  # 输出随机一个元素，比如 2
print(s)  # 输出: {1, 3}

remove() 方法：
移除集合中的指定元素，如果元素不存在，会引发 KeyError 。

s = {1, 2, 3}
s.remove(2)
print(s)  # 输出: {1, 3}

symmetric_difference() 方法：
返回两个集合中不重复的元素组成的新集合。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1.symmetric_difference(s2))  # 输出: {1, 4}

symmetric_difference_update() 方法：
在原始集合上修改，使其包含两个集合中不重复的元素。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1.symmetric_difference_update(s2)
print(s1)  # 输出: {1, 4}

union() 方法：
返回两个集合的并集，即包含两个集合中的所有不重复元素。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1.union(s2))  # 输出: {1, 2, 3, 4}

update() 方法：
将一个可迭代对象中的元素添加到集合中。

s = {1, 2}
s.update([3, 4])
print(s)  # 输出: {1, 2, 3, 4}

len() 方法：
用于计算集合中元素的个数。

s = {1, 2, 3}
print(len(s))  # 输出: 3

制作不易，请多多三连