Python 基础 （二）Python变量与基本数据类型

Python基础文章系列

Python 基础 （一）Python基本认识与环境搭建	Python 基础 （一）Python基本认识与环境搭建
Python 基础 （二）Python变量与基本数据类型	Python 基础 （二）Python变量与基本数据类型
Python 基础 （三）Python基本语句与基本运算	Python 基础 （三）Python基本语句与基本运算
Python 基础 （四）Python函数	Python 基础 （四）Python函数
Python 基础 （五）Python包与模块	Python 基础 （五）Python包与模块
Python 基础 （六）Python的文件模块	Python 基础 （六）Python的文件模块
Python 基础 （七）Python的异常处理机制	Python 基础 （七）Python的异常处理机制
Python 基础 （八）Python的类与对象	Python 基础 （八）Python的类与对象
Python 基础 （九）Python的内置模块	Python 基础 （九）Python的内置模块
Python 基础 （十）Python实现简单的图书管理系统	Python 基础 （十）Python实现简单的图书管理系统

4.1 数据类型

4.1.1 变量赋值

• 变量：变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

• 如何赋值？

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建，等号 = 用来给变量赋值。

# -- coding: utf-8 --

if __name__ == '__main__':
    print('Hello World')
    # 利用=进行赋值
    name=input('Please input your name:')
    age=100
    print('Hello',name)

• 多个变量赋值

Python允许你同时为多个变量赋值

# -- coding: utf-8 --

if __name__ == '__main__':
    print('Hello World')
    name=input('Please input your name:')
    age=100
    print('Hello',name)
    # 多个赋值
    a=b=c=1
    print(a,b,c)

4.1.2 数据类型

Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

4.1.2.1 Numbers（数字）

Python支持四种不同的数字类型：

• int（有符号整型）
• long（长整型，也可以代表八进制和十六进制）,
• float（浮点型）
• complex（复数）

种类	描述	引导符
二进制	由 0 和 1 组成	0b 或 0B
八进制	由 0 到 7 组成	0o 或 0O
十进制	默认情况	无
十六进制	由 0 到 9、a 到 f、A 到 F 组成，不区分大小写	0x 或 0X

基本使用

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:03
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  1、Python中的数字类型
# @File    : Numbers.py

if __name__ == '__main__':
        # 整数
        age=100
        print('age',age)
        # 打印变量的类型
        print(type(age))
        # 打印变量的内存地址
        print(id(age))
        # 浮点数
        salary=100.0
        print('salary',salary)
        # 打印变量的类型
        print(type(salary))
        # 打印变量的内存地址
        print(id(salary))
        # 复数
        c=1+2j
        print('c',c)
        # 打印变量的类型
        print(type(c))
        # 打印变量的内存地址
        print(id(c))
        # 布尔值
        flag=True
        print('flag',flag)
        # 打印变量的类型
        print(type(flag))
        # 打印变量的内存地址
        print(id(flag))

• 长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
• Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

**注意：**long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。

数学运算：数学模块 math，在我们的开发中会使用

• abs(x) 返回 x 的绝对值
• ceil(x) 返回 x 的上入整数，如：math.ceil(1.1) 返回 2
• floor(x) 返回 x 的下舍整数，如：math.floor(1.1) 返回 1
• exp(x) 返回 e 的 x 次幂
• log(x) 返回以 e 为底 x 的对数
• log10(x) 返回以 10 为底 x 的对数
• pow(x, y) 返回 x 的 y 次幂
• sqrt(x) 返回 x 的平方根
• factorial(x) 返回 x 的阶乘

# ---encoding:utf-8---
# @Time    : 2023/9/2 11:09
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  Math数学函数
# @File    : MathNumberTest.py

import math

if __name__ == '__main__':
    # 取余
    print(math.fmod(10, 3))
    # 向上取整
    print(math.ceil(10.1))
    # 向下取整
    print(math.floor(10.9))
    # 四舍五入
    print(round(10.5))
    # 绝对值
    print(math.fabs(-10))
    # 幂运算
    print(math.pow(10, 2))
    # 平方根
    print(math.sqrt(100))
    # 三角函数
    print(math.sin(10))

随机运算：random 模块对随机数的生成提供了支持

# ---encoding:utf-8---
# @Time    : 2023/9/2 11:14
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  随机模块
# @File    : RandomNumber.py

import random

if __name__ == '__main__':
    # 生成一个随机数
    print(random.random())
    # 生成一个指定范围的随机数
    print(random.randint(1, 10))
    # 生成一个指定范围的随机数
    print(random.randrange(1, 10))
    # 生成一个指定范围的随机数
    print(random.uniform(1, 10))
    # 生成一个指定范围的随机数
    print(random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
    # 生成一个指定范围的随机数
    print(random.sample([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k=5))
    # 生成一个指定范围的随机数
    print(random.shuffle([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
    # 百分率随机数
    print(random.random() * 100)

总结

在Python中，有几种常见的数字类型，包括整数（int）、浮点数（float）、复数（complex）。以下是这些数字类型的基本介绍：

1. 整数（int）：
   • 整数是没有小数部分的数字。
   • 例如：5、-10、0 都是整数。
   • Python的整数可以表示任意大的整数，不受限制。
2. 浮点数（float）：
   • 浮点数包含小数部分的数字。
   • 例如：3.14、-0.5 都是浮点数。
   • 浮点数的精度有限，可能会存在舍入误差。
3. 复数（complex）：
   • 复数是具有实部和虚部的数字。
   • 例如：2 + 3j 表示实部为2，虚部为3的复数。
   • 复数在一些科学和工程计算中非常有用。

Python还提供了一些数字操作和函数，可以用于处理这些数字类型，例如：

• 算术运算：可以使用加法、减法、乘法、除法等操作符对数字进行基本的算术运算。
• 类型转换：你可以使用 int()、float()、complex() 等函数将一个数字转换为不同的数字类型。
• 数学函数：Python提供了许多内置的数学函数，如 abs()（绝对值）、round()（四舍五入）、pow()（幂运算）等。
• 数学模块：还有一个名为math的标准库模块，提供了更多高级的数学函数和常数，例如三角函数、对数函数、π等。

以下是一些示例：

# 整数和浮点数
x = 5
y = 3.14

# 进行算术运算
result = x + y
print(result)

# 类型转换
int_result = int(y)
print(int_result)

# 使用math模块
import math
square_root = math.sqrt(16)
print(square_root)

4.1.2.2 String（字符串）

字符串或串(String)是由数字、字母、下划线组成的一串字符。

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:10
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  2、Python中的字符串类型
# @File    : String.py

if __name__ == '__main__':

    str='Hello World'
    print('str',str)
    # 打印变量的类型
    print(type(str))
    # 打印变量的内存地址
    print(id(str))
    # 字符串的切片
    print(str[0:5])
    # 字符串的拼接
    print(str+'你好')
    # 字符串的重复
    print(str*3)
    # 字符串的长度
    print(len(str))
    # 字符串的查找
    print(str.find('llo'))
    # 字符串的替换
    print(str.replace('llo','Darwin'))
    # 字符串的大小写转换
    print(str.upper())
    print(str.lower())
    # 字符串的首字母大写
    print(str.capitalize())
    # 字符串的每个单词首字母大写
    print(str.title())
    # 字符串的判断
    print(str.isalpha())
    print(str.isdigit())
    print(str.isalnum())
    # 字符串的分割
    print(str.split(' '))
    # 字符串的去空格
    print(str.strip())
    # 字符串的格式化
    print('我叫%s,今年%d岁'%('Darwin',18))
    print('我叫{0},今年{1}岁'.format('Darwin',18))
    print('我叫{name},今年{age}岁'.format(name='Darwin',age=18))
    print(f'我叫{"Darwin"},今年{18}岁')
    # 字符串的转义
    print('Hello\nWorld')
    print('Hello\tWorld')
    print('Hello\\World')
    print('Hello\'World')
    print('Hello\"World')
    print('Hello\rWorld')
    print('Hello\bWorld')
    print('Hello\fWorld')
    print('Hello\oooWorld')
    # 字符串的原始字符串
    print(r'Hello\nWorld')
    # 字符串的索引
    print(str[0])

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
它还有很多常用方法，截取，反转，大小写，占位符参考上面

字符串常用方法总结：

• ▍1、Slicing

slicing切片，按照一定条件从列表或者元组中取出部分元素（比如特定范围、索引、分割值）

• ▍2、strip()

strip()方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

• ▍3、lstrip()

移除字符串左侧指定的字符（默认为空格或换行符）或字符序列。

• ▍4、replace()

把字符串中的内容替换成指定的内容。

• ▍5、split()

对字符串做分隔处理，最终的结果是一个列表。

• ▍6、join()

string.join(seq)。以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串。

• ▍7、upper()

将字符串中的字母，全部转换为大写。

• ▍8、lower()

将字符串中的字母，全部转换为小写。

• ▍9、find()

检测指定内容是否包含在字符串中，如果是返回开始的索引值，否则返回-1。

• ▍10、startswith()

检查字符串是否是以指定内容开头，是则返回 True，否则返回 False。

总结

在Python中，字符串是一种非常常见的数据类型，用于表示文本数据。字符串是不可变的，这意味着一旦创建，就不能直接修改它们的内容，但可以通过创建新的字符串来实现修改。以下是关于Python字符串的基本信息和操作：

1. 创建字符串：
   • 你可以使用单引号 ' ' 或双引号 " " 来创建字符串，例如："Hello, Python!" 或 'This is a string.'
   • 你还可以使用三重引号 ''' ''' 或 """ """ 来创建多行字符串。
2. 访问字符串中的字符：
   • 你可以使用索引来访问字符串中的单个字符，索引从0开始，例如：my_string[0]。
   • 也可以使用负索引从字符串末尾开始访问，例如：my_string[-1] 表示最后一个字符。
3. 切片字符串：
   • 使用切片操作可以获取字符串的一部分，例如：my_string[2:5] 返回索引2到4的字符。
   • 切片操作包括起始索引，但不包括结束索引。
4. 字符串拼接：
   • 你可以使用 + 运算符将两个字符串拼接在一起，例如：first_name + " " + last_name。
5. 字符串长度：
   • 使用 len() 函数可以获取字符串的长度，即字符的数量。
6. 字符串方法：
   • Python提供了许多字符串方法，用于处理和操作字符串，如 upper()（将字符串转为大写）、lower()（将字符串转为小写）、strip()（去除字符串两端的空白字符）等。
7. 字符串格式化：
   • 你可以使用字符串的 format() 方法或者 f-strings（在字符串前加 f）来进行字符串格式化，以便插入变量或表达式的值。
8. 字符串转义字符：
   • 在字符串中，可以使用反斜杠符号 \ 来插入特殊字符，例如 \n 表示换行，\t 表示制表符等。
9. 字符串方法：
   • 字符串有许多内置的方法，用于查找子字符串、替换文本、拆分字符串等操作。例如 find()、replace()、split() 等。

以下是一些示例：

# 创建字符串
my_string = "Hello, Python!"

# 访问字符
first_char = my_string[0]

# 切片字符串
substring = my_string[7:13]

# 字符串拼接
first_name = "John"
last_name = "Doe"
full_name = first_name + " " + last_name

# 字符串长度
length = len(my_string)

# 字符串方法
uppercase_string = my_string.upper()
lowercase_string = my_string.lower()

# 字符串格式化
formatted_string = "My name is {} and I am {} years old.".format(name, age)

# 转义字符
escaped_string = "This is a newline.\nThis is a tab:\t\tSee?"

# 字符串方法示例
text = "Hello, World!"
index = text.find("World")
replaced_text = text.replace("World", "Python")
split_text = text.split(",")  # 分割成列表

4.1.2.3 List（列表）

• List（列表） 是 Python 中使用最频繁的数据类型。
• 列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
• 列表用 [ ] 标识，是 python 最通用的复合数据类型。
• 列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:15
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  3、Python中的列表类型
# @File    : List.py

if __name__ == '__main__':
    arr=[1,2,3,4,5,6,7,8,9,10]
    print('arr',arr)
    # 打印变量的类型
    print(type(arr))
    # 打印变量的内存地址
    print(id(arr))
    # 列表的切片
    print(arr[0:5])
    # 列表的拼接
    print(arr+[11,12,13,14,15])
    # 列表的重复
    print(arr*3)
    # 列表的长度
    print(len(arr))
    # 列表的查找
    print(arr.index(5))
    # 列表的替换
    arr[0]=100
    print(arr)
    # 列表的删除
    del arr[0]
    print(arr)
    # 列表的排序
    arr.sort()
    print(arr)
    # 列表的反转
    arr.reverse()
    print(arr)
    # 列表的追加
    arr.append(100)
    print(arr)
    # 列表的插入
    arr.insert(0,100)
    print(arr)
    # 列表的删除
    arr.remove(100)
    print(arr)
    # 列表的弹出
    print(arr.pop())
    print(arr)
    # 列表的清空
    arr.clear()
    print(arr)
    # 列表的复制
    arr=[1,2,3,4,5,6,7,8,9,10]
    arr1=arr.copy()
    print(arr1)
    # 列表的统计
    print(arr.count(1))
    # 列表的嵌套
    arr2=[1,2,3,4,5,6,7,8,9,10,[11,12,13,14,15]]
    print(arr2)
    # 列表的遍历
    for i in arr2:
        print(i)
    # 列表的推导式
    arr3=[i for i in range(1,11)]
    print(arr3)
    # 列表的推导式
    arr4=[i for i in range(1,11) if i%2==0]
    print(arr4)
    # 列表的推导式
    arr5=[i for i in range(1,11) if i%2==0 if i%3==0]
    print(arr5)

总结

Python列表是一种有序的数据结构，用于存储一组元素。它们非常灵活，可以包含不同类型的数据，包括整数、字符串、浮点数等。要创建一个Python列表，你可以使用方括号 [] 并在其中放置元素，如下所示：

my_list = [1, 2, 3, 4, 5]

这里是一些常用的列表操作和方法：

1. 访问列表元素：你可以使用索引来访问列表中的元素，索引从0开始。例如，要访问第一个元素，可以使用 my_list[0]。
2. 切片列表：通过使用切片，你可以获取列表的一部分。例如，my_list[1:3] 返回从索引1到索引2的元素。
3. 修改列表元素：你可以通过索引来修改列表中的元素，例如，my_list[0] = 10 会将第一个元素的值修改为10。
4. 添加元素：使用 append() 方法可以在列表末尾添加元素，例如，my_list.append(6) 会将6添加到列表的末尾。
5. 删除元素：你可以使用 remove() 方法根据元素的值来删除列表中的元素，或者使用 del 语句根据索引删除元素。
6. 长度：使用 len() 函数可以获取列表的长度，即其中包含的元素数量。
7. 查找元素：你可以使用 in 关键字来检查某个元素是否存在于列表中。
8. 迭代列表：你可以使用循环来迭代遍历列表中的元素。

方法总结

以下是Python列表的一些基本方法和操作：

1. 创建列表：
   • 使用方括号 [] 创建一个空列表：my_list = []
   • 使用元素初始化列表：my_list = [1, 2, 3]
2. 添加元素：
   • 使用 append() 方法在列表末尾添加元素：my_list.append(4)
   • 使用 insert() 方法在指定位置插入元素：my_list.insert(1, 5)
3. 删除元素：
   • 使用 remove() 方法根据元素的值删除元素：my_list.remove(2)
   • 使用 pop() 方法根据索引删除元素并返回它：removed_element = my_list.pop(0)
   • 使用 del 语句根据索引删除元素：del my_list[1]
4. 访问元素：
   • 使用索引来访问列表元素，索引从0开始：first_element = my_list[0]
5. 切片列表：
   • 使用切片来获取列表的一部分：my_slice = my_list[1:3]
6. 修改元素：
   • 使用索引来修改列表中的元素：my_list[0] = 10
7. 查找元素：
   • 使用 in 关键字来检查元素是否存在于列表中：if 5 in my_list:
8. 获取列表长度：
   • 使用 len() 函数来获取列表中元素的数量：list_length = len(my_list)
9. 迭代列表：
   • 使用 for 循环来遍历列表中的元素：

for item in my_list:
    print(item)

4.1.2.4 Tuple（元组）

• 元组是另一个数据类型，类似于 List（列表）。
• 元组用 () 标识，内部元素用逗号隔开，但是元组不能二次赋值，相当于只读列表。

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:21
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    : 4、Python中的元组类型
# @File    : Tuple.py

if __name__ == '__main__':
    tup=(1,2,3,4,5,6,7,8,9,10)
    print('tup',tup)
    # 打印变量的类型
    print(type(tup))
    # 打印变量的内存地址
    print(id(tup))
    # 元组的切片
    print(tup[0:5])
    # 元组的拼接
    print(tup+(11,12,13,14,15))
    # 元组的重复
    print(tup*3)
    # 元组的长度
    print(len(tup))
    # 元组的查找
    print(tup.index(5))
    # 元组的统计
    print(tup.count(1))
    # 元组的嵌套
    tup1=(1,2,3,4,5,6,7,8,9,10,(11,12,13,14,15))
    print(tup1)
    # 元组的转换
    arr=[1,2,3,4,5,6,7,8,9,10]
    tup2=tuple(arr)
    print(tup2)
    # 元组的解包
    a,b,c,d,e,f,g,h,i,j=tup2
    print(a,b,c,d,e,f,g,h,i,j)
    #元组的遍历
    for i in tup2:
        print(i)
    # 元组的比较
    tup3=(1,2,3,4,5,6,7,8,9,10)
    tup4=(1,2,3,4,5,6,7,8,9,10)
    print(tup3==tup4)
    print(tup3>tup4)
    print(tup3<tup4)

总结

在Python中，元组（Tuple）是一种有序的不可变数据类型，用于存储一组元素。与列表不同，元组一旦创建，其内容就不能被修改。元组通常用圆括号 () 来表示，其中包含逗号分隔的元素。以下是有关Python元组的基本信息和操作：

1. 创建元组：
   • 你可以使用圆括号 () 来创建一个元组，例如：(1, 2, 3)。
2. 访问元组元素：
   • 你可以使用索引来访问元组中的元素，索引从0开始，例如：my_tuple[0] 访问第一个元素。
3. 元组拆包：
   • 可以将元组的元素拆包到多个变量中，例如：x, y, z = my_tuple。
4. 不可变性：
   • 元组的元素不可被修改，这意味着你不能像列表那样使用索引来赋值新的值。
5. 元组的长度：
   • 使用 len() 函数可以获取元组中元素的数量。
6. 元组可以包含不同类型的元素：
   • 一个元组可以同时包含整数、字符串、浮点数等不同类型的元素。
7. 元组与列表的比较：
   • 元组与列表相似，但列表使用方括号 []，并且是可变的，而元组使用圆括号 ()，是不可变的。

以下是一些示例：

# 创建元组
my_tuple = (1, 2, 3)

# 访问元素
first_element = my_tuple[0]

# 元组拆包
x, y, z = my_tuple

# 元组的长度
tuple_length = len(my_tuple)

# 不可变性
# 以下代码会引发 TypeError: 'tuple' object does not support item assignment
# my_tuple[0] = 10

# 包含不同类型的元素
mixed_tuple = (1, "hello", 3.14)

# 元组与列表的比较
my_list = [1, 2, 3]  # 列表
my_tuple = (1, 2, 3)  # 元组

元组通常用于存储一组相关的值，它们的不可变性使其适用于某些特定的用途，如用作字典的键或在函数中返回多个值。如果你需要一个有序但可变的数据结构，可以使用列表；如果需要一个不可变的有序数据结构，可以使用元组。

4.1.2.5 Dictionary（字典）

• 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型，列表是有序的对象集合，字典是无序的对象集合。
• 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
• 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:24
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  5、Python中的字典类型
# @File    : Dictionary.py

if __name__ == '__main__':
    dict={'name':'Darwin','age':18,'salary':100.0,'flag':True}
    print('dict',dict)
    # 打印变量的类型
    print(type(dict))
    # 打印变量的内存地址
    print(id(dict))
    # 字典的长度
    print(len(dict))
    # 字典的查找
    print(dict['name'])
    # 字典的修改
    dict['name']='Bossen'
    print(dict)
    # 字典的删除
    del dict['name']
    print(dict)
    # 字典的清空
    dict.clear()
    print(dict)
    # 字典的复制
    dict={'name':'Darwin','age':18,'salary':100.0,'flag':True}
    dict1=dict.copy()
    print(dict1)
    # 字典的遍历
    for key in dict:
        print(key,dict[key])
    # 字典的嵌套
    dict2={'name':'Darwin','age':18,'salary':100.0,'flag':True,'dict':{'name':'Bossen','age':18,'salary':100.0,'flag':True}}
    print(dict2)
    # 字典的键值对
    print(dict2.items())
    # 字典的键
    print(dict2.keys())
    # 字典的值
    print(dict2.values())
    # 字典的更新
    dict2.update({'name':'Bossen','age':18,'salary':100.0,'flag':True})
    print(dict2)
    # 字典的弹出
    print(dict2.pop('name'))
    print(dict2)
    # 字典的弹出随机键值对
    print(dict2.popitem())
    print(dict2)
    # 字典的fromkeys
    dict3=dict.fromkeys(['name','age','salary','flag'])
    print(dict3)
    # 字典的get
    print(dict2.get('name'))
    # 字典的setdefault
    print(dict2.setdefault('name','Darwin'))
    print(dict2)
    # 遍历字典的键值对
    for key,value in dict2.items():
        print(key,value)
    # 遍历字典的键
    for key in dict2.keys():
        print(key)
    # 遍历字典的值
    for value in dict2.values():
        print(value)

总结

在Python中，字典（Dictionary）是一种无序的数据结构，用于存储键-值对（key-value pairs）。字典是可变的，允许你添加、删除和修改键值对。字典通常用花括号 {} 来表示，每个键值对由冒号 : 分隔，键和值之间由逗号 , 分隔。以下是有关Python字典的基本信息和操作：

1. 创建字典：
   • 你可以使用花括号 {} 来创建一个空字典：my_dict = {}。
   • 或者使用大括号包含键值对来初始化字典：my_dict = {'name': 'John', 'age': 30}。
2. 访问字典的值：
   • 你可以使用键来访问字典中的值，例如：name = my_dict['name']。
3. 添加新的键值对：
   • 使用赋值语句可以添加新的键值对，例如：my_dict['city'] = 'New York'。
4. 修改键值对的值：
   • 通过指定已存在的键，你可以修改其对应的值，例如：my_dict['age'] = 31。
5. 删除键值对：
   • 使用 del 语句可以删除字典中的键值对，例如：del my_dict['age']。
6. 检查键是否存在：
   • 使用 in 关键字可以检查某个键是否存在于字典中，例如：if 'name' in my_dict:。
7. 获取字典的键和值：
   • 使用 keys() 方法可以获取字典中的所有键，values() 方法可以获取所有的值，items() 方法可以获取键值对组成的元组。
8. 字典的长度：
   • 使用 len() 函数可以获取字典中键值对的数量。

以下是一些示例：

# 创建字典
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

# 访问值
name = my_dict['name']

# 添加新键值对
my_dict['job'] = 'Engineer'

# 修改值
my_dict['age'] = 31

# 删除键值对
del my_dict['city']

# 检查键是否存在
if 'name' in my_dict:
    print(f"Name: {my_dict['name']}")

# 获取键和值
keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()

# 字典的长度
dict_length = len(my_dict)

字典是一种非常有用的数据结构，常用于存储和检索具有关联性的数据。键必须是不可变的类型，如字符串或数字，而值可以是任何数据类型，包括列表、元组、其他字典等。

4.1.2.6 Set 集合

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

# ---encoding:utf-8---
# @Time    : 2023/9/2 14:25
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  Set集合
# @File    : Set.py

if __name__ == '__main__':
    set1 = {1, 2, 3, 4}  # 直接使用大括号创建集合
    set2 = set([4, 5, 6, 7])  # 使用 set() 函数从列表创建集合
    print(set1)
    # 集合的基本操作
    # 1.添加元素
    set1.add(5)
    print(set1)
    # 2.删除元素
    set1.remove(5)
    print(set1)
    # 3.集合的并集
    print(set1 | set2)
    # 4.集合的交集
    print(set1 & set2)
    # 5.集合的差集
    print(set1 - set2)
    # 6.集合的对称差
    print(set1 ^ set2)
    # 7.判断元素是否在集合中
    print(1 in set1)
    print(1 not in set1)
    # 8.判断子集和超集
    print(set1 <= set2)
    print(set1 >= set2)
    # 9.清空集合
    set1.clear()
    print(set1)
    # 10.集合的长度
    print(len(set2))
    # 11.集合的拷贝
    set3 = set2.copy()
    print(set3)
    # 12.集合的遍历
    for item in set2:
        print(item)

总结

Python中的集合是一种无序的数据结构，它包含唯一的元素。在Python中，你可以使用set来创建一个集合，或者使用花括号{}来创建一个集合字面量。下面是一些关于Python集合的基本操作和信息：

1. 创建集合：

my_set = set()  # 创建一个空集合
my_set = {1, 2, 3}  # 创建一个包含元素的集合

2. 添加元素：

my_set.add(4)  # 向集合中添加元素4

3. 移除元素：

my_set.remove(2)  # 从集合中移除元素2，如果元素不存在会引发KeyError
my_set.discard(3)  # 从集合中移除元素3，如果元素不存在不会引发错误

4. 集合操作：
   • 并集：union方法或|操作符
   • 交集：intersection方法或&操作符
   • 差集：difference方法或-操作符
   • 对称差集：symmetric_difference方法或^操作符

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)  # 或者使用 set1 | set2
intersection_set = set1.intersection(set2)  # 或者使用 set1 & set2
difference_set = set1.difference(set2)  # 或者使用 set1 - set2
symmetric_difference_set = set1.symmetric_difference(set2)  # 或者使用 set1 ^ set2

5. 其他集合操作方法和函数：
   • issubset()：判断一个集合是否为另一个集合的子集。
   • issuperset()：判断一个集合是否为另一个集合的超集。
   • clear()：清空集合中的所有元素。
   • copy()：复制集合。
   • len()：获取集合的元素数量。

4.12.6 类型转换

# ---encoding:utf-8---
# @Time    : 2023/9/2 10:27
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  6、Python中的类型转换
# @File    : CoverType.py


if __name__ == '__main__':

    name='Darwin'
    age=18
    salary=100.0
    flag=True
    arr=[1,2,3,4,5,6,7,8,9,10]
    tup=(1,2,3,4,5,6,7,8,9,10)
    dict={'name':'Darwin','age':18,'salary':100.0,'flag':True}
    # int()函数
    print(int(salary))
    # float()函数
    print(float(age))
    # complex()函数
    print(complex(age))
    # bool()函数
    print(bool(age))
    # str()函数
    print(str(age))
    # list()函数
    print(list(tup))
    # tuple()函数
    print(tuple(arr))

• 有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
• 以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串