python数据类型学习记录--神话与数据类型

目录

1.众神云集--数字类型

1.1 玉皇大帝--整数(int)

1.2 嫦娥--浮点数(float)

1.3 太上老君--复数(complex)

1.4 数字类型的通用特性

1.4.1 类型转换

1.4.2 数学函数

1.4.3 随机数及随机数的复现

2. 齐天大圣--字符串类型

2.1 字符串的创建

2.2 字符串常见操作

2.3 字符串的其他用法

2.4 字符串格式化

2.4.1 %格式化

2.4.2 str.format()

2.4.3 f-string

2.4.4 原始字符串

3. 蟠桃盛会--列表类型(list)

3.1 列表的基本特性

3.2 列表的创建

3.3 列表的常见操作

3.4 列表的其他用法

3.5 列表的拷贝

3.5.1 浅拷贝

3.5.2 深拷贝

 3.6 总结

4. 南天门--元组类型(tuple)

4.1 元组的创建

4.2 元组的常见操作

4.3 元组的其他方法

4.4 总结

5. 八卦炉--集合类型(set)

5.1 集合的特性

5.2 集合的创建

5.3 集合的常见操作

5.4 集合的数学运算

5.5 集合的其他用法

5.6 总结

6. 天书--字典(dict)

6.1 字典的基本特性

6.2 字典的创建

6.3 字典的常见操作

6.4 字典的其他用法

6.5 默认字典

6.6 总结

1.众神云集--数字类型

1.1 玉皇大帝--整数(int)

python中的整数，可以管理任意大的数字，只要内存够大，就能够一直数下去

a = 1234567890987654321
b = 8888888888888888888

print(a * b) # 10973936808779149518902606319122085048

关于整数的基本运算包括下面几种：

# 创建整数
a = 10
b = -5
c = 0

# 基本运算
sum_result = a + b  # 5
diff_result = a - b  # 15
prod_result = a * b  # -50
div_result = a / b  # -2.0 结果为浮点数
floor_div_result = a // b  # -2 地板除，向下取整到最接近的整数

# 取余
mod_result = a % b  # 0

# 幂运算
power_result = a ** 2  # 100

python也可以表示不同进制的整数：

# 十进制10的表示方法
binary_num = 0b1010 # 二进制
octal_num = 0o12 # 八进制
hex_num = 0xA # 十六进制

1.2 嫦娥--浮点数(float)

浮点数可以表示非常精确的数字，但由于采用IEEE754的表示方法，有时可能存在精度问题

# 0.3 与 0.1+0.2
print(0.3 == (0.1 + 0.2)) #False

如果想让两者相等，可以调用decimal模块

import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
c = decimal.Decimal('0.3')
print(c == a+b) # True

关于浮点数的基本运算包括下面几种，对于结果可以采用round函数指定保留的小数位数：

x = 3.14
y = -0.001
z = 2.0

# 基本运算
sum_result = x + y  # 3.139
diff_result = x - y  # 3.141
prod_result = x * y  # -0.00314
div_result = x / y  # -3140.0

# 幂运算
power_result = round(x ** 2, 2)  # 9.86，第二个参数指定四舍五入后要保留的小数点位数

# 科学计数法表示
sci_num = 1.23e-4  # 0.000123

1.3 太上老君--复数(complex)

复数虚虚实实，由实数部分和虚数部分构成

c1 = 2 + 3j
c2 = 4 - 5j

关于复数的基本运算包括下面几种：

c1 = 2 + 3j
c2 = 4 - 5J

# 基本运算
sum_result = c1 + c2  # (6-2j)
diff_result = c1 - c2  # (-2+8j)
prod_result = c1 * c2  # (23+2j)
div_result = c1 / c2  # (-0.12195121951219512+0.5609756097560976j)

# 获取实部和虚部
real_part = c1.real  # 2.0
imaginary_part = c1.imag  # 3.0

#幂运算及取模
power_result = c1 ** 2  # (-5+12j)
modulus = abs(c1)  # 3.605551275463989 (复数的模)

1.4 数字类型的通用特性

1.4.1 类型转换

# 整数转浮点数
float_num = float(10)  # 10.0

# 浮点数转整数
int_num = int(3.14)  # 3 (会丢失小数部分)

# 字符串转数字
num_from_str = int("123")  # 123
float_from_str = float("3.14")  # 3.14

1.4.2 数学函数

python的math模块提供了丰富的数学函数：

import math

# 平方根
sqrt_result = math.sqrt(16)  # 4.0

# 对数
log_result = math.log(100, 10)  # 2.0

# 三角函数
sin_result = math.sin(math.pi / 2)  # 1.0

1.4.3 随机数及随机数的复现

python中提供了模块可以生成随机数，但是该随机数也是可以复现的

import random

# 生成1-10之间的随机整数
random_int = random.randint(1, 10)

# 生成0.0-1.0的随机浮点数
random_float = random.random()

# 复现随机数--使用getstate和setstate
x = random.getstate()
random_int = random.randint(1, 20)
random.setstate(x)
random_int = random.randint(1, 20)

2. 齐天大圣--字符串类型

灵活多变，擅长拼接、切片、格式化变化自己

s1 = "Hello,world!"
s2 = "Python Programming"

substring = s1[6:12] # world!

2.1 字符串的创建

使用引号或者函数str创建字符串，python会根据赋值自动推断变量的类型：

# 使用单引号
s = 'hello'

# 使用双引号
s2 = "hello"

# 使用三引号：适用于多行字符串的创建
s3 = """hello
world"""

# 使用str函数
s4 = str(123)

2.2 字符串常见操作

# 拼接
s1 = "hello"
s2 = "world"
s3 = s1 + " " + s2 # hello world
s4 = s1 * 3

length = len(s1) # 求长度

char = s1[0] # 字符串索引

substring = s1[1:4] # 切片，左闭右开

2.3 字符串的其他用法

# 大小写转换
s = "Python"
lower_case = s.lower() # python
upper_case = s.upper() # PYTHON
capitalize_case = s.capitalize() # 首字母大写
casefold.case = s.casefold() # 所有字母小写
title_case = s.title() # 所有首字母大写
swapcase_case = s.swapcase() # 大小写转换

# 去除空白字符
s = "   Python   "
stripped = s.strip() # Python

#字符串替换
s = "hello world"
replaced = s.replace("world", "Python") # hello Python

# 字符串分割
s = "a, b, c"
split_result = s.split(",") # 返回一个list

# 字符串查找
s = "hello world"
index = s.find("world")

# 字符串检查
s = "Python"
is_alpha = s.isalpha() # 检查是否全是字母
is_digit = s.isdigit() # 检查是否全是数字

# 统一tab宽度
code = """
    print("I love Fishc")
      print("I love my wife")"""
new_code = code.expandtabs(4)

# 字符串替换
"你好，你有一个帽衫".replace("你好", "闭嘴")

2.4 字符串格式化

python中的字符串格式化包括以下几种方式：%格式化(旧版)、str.format()方法(python 2.6引入)、s-string(python 3.6引入)

2.4.1 %格式化

这是python最早的字符串格式化方式，语法类似于C语言中的printf函数。格式化的字符串中包含占位符，利用占位符为值预留位置。

# 基本用法
“格式化字符串” % (值1, 值2, ...)

# 示例
name = "Alice"
age = 25
height = 1.68

result = "Name: %s, Age: %d, Height: %.2f" % (name, age, height)
print(result)

2.4.2 str.format()

作为python 2.6引入的字符串格式方法，比%格式化更强大、更灵活。格式化字符串中使用{}作为占位符，{}中可以指定索引或名称来引用后面的值。

name = "Alice"
age = 25
height = 1.68

# 按位置引用
result1 = "Name: {}, Age: {}, Height: {}".format(name, age, height)
print(result1)

# 按索引引用
result2 = "Name: {1}, Age: {0}, Height: {2:.2f}".format(age, name, height)
print(result2)

# 按名称引用
result3 = "Name: {names}, Age: {ages}, Height: {heights}".format(names = name, ages = age, heights = height)
print(result3)

str.format()也支持对于字符串的对齐与填充，对数字进行格式化

# 左对齐，宽度为10，填充字符为‘-’
result_l = "{:-<10}".format("python") # ><表示对齐方向,前面的代表填充字符

# 右对齐，宽度为10，填充字符为‘*’
result_r = "{:*>10}".format("python")

# 居中对齐，宽度为10，填充字符为‘=‘
result_m = "{:=^10}".format("python")

# 保留两位小数
result_1 = "{:.2f}".format(3.14159)

# 科学计数法
result_2 = "{:.2e}".format(123456789)

# 千位分隔符
result_3 = "{:,}".format(123456789)

2.4.3 f-string

作为python 3.6引入的字符串格式化方式，它结合了%格式化的简洁性和str.format()的强大功能。但是要注意，该方式仅适用于python3.6及以上版本。

基本语法：直接在字符串前面加上 f 或者 F，在{}中写入变量或表达式。

f"格式化字符串"

在%格式化字符串、str.format()格式化字符串中的方法应用到此处：

name = "Alice"
age = 25
result = f"Name: {name}, Age: {age}"
print(result)

# 格式化数字
pi = 3.14159
result_num = f"pi rounded to 2 decimal places: {pi:.2f}"
print(result_num)

# 对齐与填充
name = "python"
result_str = f"{name:-<10}"
print(result_str)

# 调用函数或方法
result_func = f"Name is uppercase: {name.upper()}"
print(result_func)

# 嵌套格式化
value = 123.456
result = f"Formatted value: {value:.2f} ({value:.1e})"
print(result) # Formatted value: 123.46 (1.2e+02)

2.4.4 原始字符串

# r"string"--使转义字符不再发挥作用
print(r"D:\three\two\one") # D:\three\two\one

3. 蟠桃盛会--列表类型(list)

神仙来来往往，列表也可以随意添加、删除、修改元素，想怎么变就怎么变。它既可以储存各种类型的数据集合，还可以实现复杂的算法。

my_list = [1, 2, 3, 'python', 3.14]
my_list.append('new element') # [1, 2, 3, 'python', 3.14, 'new element']
my_list.pop(2) # 3

3.1 列表的基本特性

有序性：列表中的元素都是有序的，每个元素都一个对应的索引（从0开始）；

可变性：列表元素都是可变的，可以动态添加、删除或修改元素；

异构性：列表可以储存不同类型的元素，包括整数、字符串、其他列表等。

3.2 列表的创建

# 使用方括号[]
my_list = [1, 2, 3, 4, 5]

# 使用list()函数
my_list. = list(range(5))

# 使用列表推导式
my_list = [x ** 2 for x in range(5)]

3.3 列表的常见操作

通常，我们需要访问列表元素，对列表进行增删补元素等操作。

# 访问列表元素
my_list = [10, 20, 30]

print(my_list[0]) # 索引访问
print(my_list[1:3]) # 切片访问 左闭右开

#修改元素
my_list[1] = 200
print(my_list)

# 添加元素
my_list.append(40) # 在列表末尾添加一个元素
print(my_list)

my_list.extend([50, 60]) # 在列表末尾添加多个元素
print(my_list)

my_list.insert(1, 15) # 在指定索引值位置插入一个元素
print(my_list)

# 删除元素
my_list.remove(200) # 删除第一个匹配到的元素
print(my_list)

popped_element = my_list.pop(1) # 删除并返回指定索引位置的元素
print(popped_element)
print(my_list)

del my_list[2] # 删除指定索引位置的元素
print(my_list)

# 列表长度
length = len(my_list)

# 列表排序
my_list = [3, 1, 4, 1, 5, 9]
my_list.sort() # 对列表进行原地排序，排序后列表改变
print(my_list)

my_list = [3, 1, 4, 1, 5, 9]
sorted_list = sorted(my_list) # 返回一个新的排序列表，原列表不变
print(sorted_list)

# 列表反转
sorted_list.reverse() # 原地反转列表，反转后原列表改变
print(sorted_list)

reversed_list = sorted_list[::-1]
print(reversed_list)

3.4 列表的其他用法

# 列表推导式
squares = [x ** 2 for x in range(10)]
print(squares)

# 嵌套列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(squares)

3.5 列表的拷贝

在python中，列表的浅拷贝和深拷贝是两种不同的复制方式，它们的主要区别是如何处理嵌套对象。

3.5.1 浅拷贝

浅拷贝会创建一个新的列表对象，但只复制原列表的顶层元素。如果列表中的元素是可变对象，浅拷贝只会复制这些对象的引用，而不是创建新的对象。

当列表中的嵌套对象是不可变的（元组、字符串等）时，可以使用浅拷贝。

list1 = [1, 2, [3, 4]]
list2 = list1.copy()

# 修改顶层元素
list2[0] = 100
print(list1) # 输出：[1, 2, [3, 4]]
print(list2) # 输出：[100, 2, [3, 4]]

# 修改嵌套对象
list2[2][0] = 300
print(list1) # 输出：[1, 2, [300, 4]]
print(list2) # 输出：[100, 2, [300, 4]]

3.5.2 深拷贝

深拷贝会创建一个新的列表对象，并递归地复制原列表中的所有嵌套对象。也就是说，深拷贝完全独立于原列表。

当列表中的嵌套对象是可变的（列表、字典）且需要完全独立复制时，必须使用深拷贝。

# 深拷贝采用copy.deepcopy()函数实现
import copy

list1 = [1, 2, [3, 4]]
list2 = copy.deepcopy(list1)

# 修改顶层元素
list2[0] = 100
print(list1) # 输出：[1, 2, [3, 4]]
print(list2) # 输出：[100, 2, [3, 4]]

# 修改嵌套对象
list2[2][0] = 300
print(list1) # 输出：[1, 2, [3, 4]]
print(list2) # 输出：[100, 2, [300, 4]]

 3.6 总结

深拷贝会递归复制所有嵌套对象，因此当嵌套层次较深或数据量较大时，深拷贝会消耗更多的内存和时间；

如果列表中的嵌套对象是可变的，浅拷贝可能会导致意外的改变；

如果列表中的嵌套对象是不可变的，浅拷贝和深拷贝的效果是一样的。

4. 南天门--元组类型(tuple)

一旦建成，不能随意改动，是和储存不变的数据。

my_tuple = (1, 2, 3, 'python', 3.14)

与列表相似，元组也具有有序性和异构性，但是元组具有不可变性，其内容不可被修改。

4.1 元组的创建

# 使用圆括号()
my_tuple = (1, 2, 3, 4)

# 使用tuple()函数
my_tuple = tuple([1, 2, 3, 4])

# 单元素元组
single_tuple = (1,) # 需要在元素后面加一个逗号
not_a_tuple = (1) # 整数

4.2 元组的常见操作

元组的常见操作类似于列表：

# 访问元素
my_tuple = (10, 20, 30)
print(my_tuple[0]) # 索引访问
print(my_tuple[1:3]) # 切片访问

# 元组长度
length = len(my_tuple)

# 元组拼接
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2
print(combined_tuple) # (1, 2, 3, 4, 5, 6)

# 元组重复
repeated_tuple = tuple1 * 3
print(repeated_tuple) # (1, 2, 3, 1, 2, 3, 1, 2, 3)

# 元组解包--解包到多个变量中
my_tuple = (10, 20, 30)
a, b, c = my_tuple
print(a, b, c)

# 元组解包--使用*解包剩余元素
a, *b = my_tuple # 以列表的形式返回剩余元素
print(a)
print(b)

4.3 元组的其他方法

# count()
my_tuple = (1, 2, 2, 3, 2)
count = my_tuple.count(2)

# index()
index = my_tuple(3)

# 与列表相互转换
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
new_list = list(my_tuple)

4.4 总结

元组创建之后，其内容就不能被修改。如果需要修改，可以先转换为列表，修改后再转回元组；

元组的不可变性使其在某些情况下比列表更高效，例如作为字典的键，当函数返回多个值时使用；

5. 八卦炉--集合类型(set)

无序，支持高效的成员检测和去重操作，练出最纯净的“丹药”。

my_set = {1, 2, 3, 4, 4}
my_set.add(5) # {1, 2, 3, 4, 5}
my_set.remove(3) # {1, 2, 4, 5}

5.1 集合的特性

相较于列表和元组，集合的特性略有不同。

无序性：集合中的元素是无序的，这也代表着不能通过索引访问；

唯一性：集合中的元素是唯一的，重复的元素会被自动去重；

可变性：集合是可变的，可以动态添加或删除元素

5.2 集合的创建

# 使用花括号{}
my_set = {1, 2, 3}

# 使用set()函数
my_set = set([1, 2, 3])

# 空集合
empty_set = set()
not_a_set = {} # 这是一个字典

5.3 集合的常见操作

集合的元素也是可变的，可以对齐进行增删修改元素的操作。

# 增加元素
my_set = {1, 2, 3}
my_set.add(4) # add添加单个元素
print(my_set)

my_set.update([5, 6, 7]) # update添加多个元素
print(my_set)

# 删除元素
my_set.remove(3) # 删除指定元素，如果元素不存在会报错

my_set.discard(10) # 删除指定元素，如果元素不存在也不会报错

popped_element = my_set.pop() # 随机删除并返回一个元素
print(popped_element)
print(my_set)

my_set.clear() # 清空集合
print(my_set)

# 集合长度
length = len(my_set)

# 成员检测
if 2 in my_set:
    print("2在集合中")

5.4 集合的数学运算

# 并集
set1 = {1, 2, 3}
set2 = {4, 5, 3}
union_set = set1 | set2
print(union_set)

# 交集
intersection_set = set1 & set2
print(intersection_set)

# 差集--返回第一个集合有而第二个集合没有的元素
difference_set = set1 - set2
print(difference_set)

# 对称差集--返回两个集合中不重复的元素
symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)

5.5 集合的其他用法

# 集合推导式
squares = {x ** 2 for x in range(10)}
print(squares)

# 不可变集合
frozen_set = frozenset([1, 2, 3])
my_dict = {frozen_set:"value"}
print(my_dict[frozen_set])

5.6 总结

集合中的元素是无序的，因此不能通过索引访问；

集合可以自动去重，确保元素唯一；

集合是可变的，但是frozenset是不可变的；

集合中的元素必须是可哈希的（即不可变的），因此列表不能作为集合的元素 

6. 天书--字典(dict)

通过键值对可以快速查找和存储数据，就像天书能瞬间找到任何神仙的信息。

my_dict = {"name": "alice", "age": 24, "city": "New York"}
my_dict["email"] = "[email protected]" # 新增一条记录

6.1 字典的基本特性

键值对结构：字典中的每一个元素都是一个键值对，键与值之间用冒号分隔；

无序性：在python 3.7之前，字典中的元素是无序的。在python 3.7之后，字典保持插入顺序；

可变性：字典是可变的，可以动态的添加、删除或修改键值对；

键的唯一性：字典中的键是唯一的，如果重复，后面的值会覆盖前面的值。

6.2 字典的创建

# 使用花括号创建
my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 使用dict()函数创建
my_dict = dict(name="Alice", age=25, city="New York")

# 使用键值对列表
my_dict = dict([("name", "Alice"), ("age", 25), ("city": "New York")])

# 空字典
empty_dict = {}

6.3 字典的常见操作

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 访问元素
name = my_dict["name"] # 通过键访问值
age = my_dict.get("age") # 使用get()方法访问值，如果不存在，返回默认值

# 修改元素
my_dict["age"] = 26

# 添加元素
my_dict["email"] = "[email protected]"

# 删除元素
del my_dict["city"] # 删除指定键值对

age = my_dict.pop("age") # 删除并返回指定键的值

key, value = my_dict.popitem() # 删除并返回最后一个键值对

my_dict.clear() # 清空字典

# 字典长度
length = len(my_dict)

# 成员检测
if "name" in my_dict:
    print("name 在字典中")

6.4 字典的其他用法

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# keys()--返回字典中所有的键
keys = my_dict.keys()

# values()--返回字典中所有的值
values = my_dict.values()

# items()--返回字典中所有的键值对
items = my_dict.items()

# update()--用另一个字典更新当前字典
my_dict.update({"eamil": "[email protected]"})
print(my_dict)

# get()--获得字典中键对应的值
my_dict.get('home', '不存在') # 指定当找不到键的时候返回的值
print(my_dict)

# setdefault()--获得字典中键对应的值，如果不存在，将默认值存入字典
my_dict.setdefault('home', 'nothing')
print(my_dict)

6.5 默认字典

defaultdict是一个特殊的字典，可以为不存在的键提供默认值

from collections import defaultdict

my_dict = defaultdict(int) # 0
my_dict["count"] += 1
print(my_dict["count"]) # 1

6.6 总结

键的唯一性：字典中的键必须是唯一的，重复时，后面的值会覆盖前面的值；

键的类型：字典中的键必须是可哈希的（不可变的），因此列表不能作为字典的解释键；

性能：字典的查找、插入、删除的平均时间复杂度为O(1)，在配置项管理、数据统计以及处理映射关系方面非常高效。