【Python】数据类型、内置方法、互相转换、排序算法

原文作者：我辈李想
版权声明：文章原创，转载时请务必加上原文超链接、作者信息和本声明。

---

前言

数据类型和算法是日常开发的基础，虽然我们可能一直没怎么在意。我们了解的基础数据类型包括整型、浮点型、布尔类型、字符型、字节型等，组合数据类型包括列表、元祖、字典、集合。如果想要使用这些数据类型，就需要知道不同语言对这些数据两类型内置了那些方法，比如新增、读取、修改、删除。
这些基本和内置数据类型和方法如果不能满足我们，就需要自定义数据结构和算法，就比如队列、链表等。

---

一、基础数据类型

基础数据类型为整型、浮点型、布尔型、 复数型、字符型、字节型。

1.整型

intvar = 1000
# id获取内存地址
print (id(intvar),intvar)
# type获取数据类型
print (type(intvar),intvar)

139642987649936 1000
 1000

2.浮点型

floatvar = 3.14
print(type(floatvar),floatvar)

 3.14

3.布尔型

boolvar = True
print(type(boolvar),boolvar)

 True

4.复数型

complexvar = 2 + 3j
complexvar2 = complex(3,-91)
print(type(complexvar),complexvar)
print(type(complexvar2),complexvar2)

 (2+3j)
 (3-91j)

5.字符型

# 字符型
str_var = "Hello, World!"
print(type(str_var), str_var)

  Hello, World!

# 多行字符串
multi_str = """This is a 
multi-line string"""
print(type(multi_str), multi_str)

 This is a 
multi-line string

# 单引号字符串
single_str = 'This string is in single quotes'
print(type(single_str), single_str)

 This string is in single quotes

# 字节型
bytes_var = b"byte string"
print(type(bytes_var), bytes_var)

 b'byte string'

6.数字型内置方法

python对数字方面的类型提供了很多内置方法（），数字运算包括加减乘除,除此之外还有幂次运算、根号运算；逻辑运算包括或与非等。

内置方法名称如下

1. bit_length()：返回该整数的二进制表示长度。
2. to_bytes(length, byteorder, *, signed=False)：返回指定长度和字节序的字节串。
3. from_bytes(bytes, byteorder, *, signed=False)：将字节串转换为整数。
4. add(self, other)：实现加法操作。
5. sub(self, other)：实现减法操作。
6. mul(self, other)：实现乘法操作。
7. floordiv(self, other)：实现整除操作。
8. truediv(self, other)：实现真除法操作。
9. mod(self, other)：实现取余操作。
10. pow(self, other[, modulus])：实现幂运算。
11. lshift(self, other)：实现左移位操作。
12. rshift(self, other)：实现右移位操作。
13. and(self, other)：实现按位与操作。
14. or(self, other)：实现按位或操作。
15. xor(self, other)：实现按位异或操作。

除此之外，+和-也是通用的运算方法

#加法
def add(a,b):
    return a+b

#减法
def subtract(a,b):
    return a-b

#乘法
def multiply(a,b):
    return a*b

#除法
def divide(a,b):
    if b == 0:
        raise ValueError("除数不能为0")
    return a/b

#示例
a = 10
b = 5
print(f"{a} + {b} = {add(a,b)}")
print(f"{a} - {b} = {subtract(a,b)}")
print(f"{a} * {b} = {multiply(a,b)}")
print(f"{a} / {b} = {divide(a,b)}")

7.字符型内置方法

内置方法

1. capitalize()：将字符串第一个字符转换为大写。
2. casefold()：将字符串中的所有字符转换为小写。
3. center(width[, fillchar])：返回一个指定宽度，以字符串居中并用 fillchar 填充的字符串。
4. count(sub[, start[, end]])：返回 sub 在字符串中出现的次数，可指定起始和结束位置。
5. encode(encoding=“utf-8”, errors=“strict”)：将字符串编码为指定格式。
6. endswith(suffix[, start[, end]])：判断字符串是否以指定的后缀结尾，可指定起始和结束位置。
7. find(sub[, start[, end]])：返回 sub 在字符串中第一次出现的位置，可指定起始和结束位置。
8. index(sub[, start[, end]])：返回 sub 在字符串中第一次出现的位置，如果不存在则报错，可指定起始和结束位置。
9. isalnum()：判断字符串是否只包含字母和数字。
10. isalpha()：判断字符串是否只包含字母。
11. isdecimal()：判断字符串是否只包含十进制数字。
12. isdigit()：判断字符串是否只包含数字。
13. islower()：判断字符串是否全是小写。
14. isnumeric()：判断字符串是否只包含数字字符。
15. isspace()：判断字符串是否只包含空格。
16. istitle()：判断字符串是否符合标题要求。
17. isupper()：判断字符串是否全是大写。
18. join(iterable)：将 iterable 中的元素以指定字符连接成一个字符串。
19. ljust(width[, fillchar])：返回一个指定宽度，以字符串左对齐并用 fillchar 填充的字符串。
20. lower()：将字符串中的所有字符转换为小写。
21. lstrip([chars])：返回去除左侧指定字符后的字符串。
22. partition(sep)：将字符串以 sep 分隔成三部分，返回一个元组 (head, sep, tail)。
23. replace(old, new[, count])：将字符串中的 old 字符串替换为 new 字符串，可指定最大替换次数。
24. rfind(sub[, start[, end]])：返回 sub 在字符串中最后一次出现的位置，可指定起始和结束位置。
25. rindex(sub[, start[, end]])：返回 sub 在字符串中最后一次出现的位置，如果不存在则报错，可指定起始和结束位置。
26. rjust(width[, fillchar])：返回一个指定宽度，以字符串右对齐并用 fillchar 填充的字符串。
27. rpartition(sep)：将字符串以 sep 分隔成三部分，返回一个元组 (head, sep, tail)。
28. rstrip([chars])：返回去除右侧指定字符后的字符串。
29. split([sep[, maxsplit]])：将字符串以指定分隔符 sep 分割，返回一个列表。
30. splitlines([keepends])：将字符串分割成一行一行的，返回一个列表。
31. startswith(prefix[, start[, end]])：判断字符串是否以指定的前缀开头，可指定起始和结束位置。
32. strip([chars])：返回去除两侧指定字符后的字符串。
33. swapcase()：将字符串中的大写字母转换为小写字母，小写字母转换为大写字母。
34. title()：将字符串转换为标题格式。
35. upper()：将字符串中的所有字符转换为大写。

二、组合数据类型

Python 中常用的组合数据类型有列表、元组、集合和字典等。可以进行的操作包括索引，切片，加，乘，检查成员。

1.列表

列表是一种有序、可变的数据类型，可以存储任意数量、类型的元素。

my_list = [1, 2, 3, "apple", "banana"]
print(type(my_list ),my_list )

 [1, 2, 3, 'apple', 'banana']

常用的内置方法

创建列表的方法：

# 通过[]直接创建
my_list1 = [1, 2, 3, "apple", "banana"]
# 通过list类创建
my_tuple = ("apple", 2, 3.14, True)
my_list2 = list(my_tuple)

列表中增添元素功能（方法）：

1. 列表.insert(下标，元素）——在指定下标处插入指定的元素
2. 列表.append（元素）——在列表尾部追加一个元素
3. 列表.extend（数据容器）——将数据容器中的元素一次添加到列表尾部

列表中删除元素功能（方法）：

1. del 列表[下标]——删除列表该下标下的元素
2. 列表.pop（下标）——同上
3. 列表.remove（元素）——从前往后（从左至右）删除与括号内元素相同的列表元素
4. 列表.clear（）——清空列表中所有元素

列表中统计元素功能（方法）：

1. 列表.count（元素）——统计括号内元素在列表中出现的次数
2. len（列表）——统计列表元素的总个数

列表中查找下标功能（方法）：

1. 列表.index（元素）——查找指定元素在列表中的下标，如果找不到会报错

值得记住的遍历方法

fruits = ['apple', 'banana', 'orange', 'grape']

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 orange
3 grape

2.元组

元组是一种有序、不可变的数据类型，可以存储任意数量、类型的元素。

my_tuple = ("apple", 2, 3.14, True)
print(type(my_tuple),my_tuple)

 ('apple', 2, 3.14, True)

常用的内置方法

1. 元组.index（元素）——查找指定元素在元组中的下标
2. 元组.count（元素）——统计指定元素在元组中的数量
3. len（元组）——统计元组中所有元素的总个数

3.集合

集合是一种无序、可变的数据类型，不允许有重复的元素。

my_set = {1, 2, 3, "apple", "banana", "apple"}
print(type(my_set),my_set)

 {1, 2, 3, 'apple', 'banana'}

常用内置方法

1. 集合.add（元素）——向集合内添加一个元素
2. 集合.remove(元素）——移除集合内指定的元素
3. 集合.pop（）——从集合中随机取出一个元素
4. 集合.clear（）——清空集合
5. 集合1.difference（集合2）——得到一个新的集合，该集合的数据为两个集合的差集，原来的集合1和集合2中的数据不发生改变
6. 集合1.difference_update（集合2）——在集合1中删除与集合2相同的元素，集合发生改变，集合2不发生改变。
7. 集合1.union（集合2）——得到一个新的集合，该集合的数据为两个集合中的全部元素（不重复），集合1和集合2不发生改变。
8. len（集合）——添加集合中的元素总个数

4.字典

字典是一种无序、可变的数据类型，以键值对的形式存储数据。

# 1
my_dict = {"name": "Alice", "age": 20, "gender": "female"}
print(type(my_dict),my_dict)
# 2.
dic = dict(a = 1, b = 2, c = 3)
# 3.
list = [('aaa', 1), ('bbb', 2), ('ccc', 3)]
dic = dict(list)
# 4.
dic = dict(zip(['a','b','c'], [1, 2, 3]))
# 5.
list1 = ['a','b','c']
dic = dict.fromkeys(list1)

  {'name': 'Alice', 'age': 20, 'gender': 'female'}

常用的内置方法

1. clear()：删除字典内所有元素。
2. copy()：返回一个字典的浅复制。
3. keys()：返回一个包含字典所有 key 的列表。
4. values()：返回一个包含字典所有 value 的列表。
5. items()：返回一个包含字典所有 (key, value) 元组的列表。
6. get(key, default=None)：获取指定 key 对应的 value。如果 key 不存在，则返回 default。
7. pop(key, default=None)：删除并返回指定 key 对应的 value。如果 key 不存在，则返回 default。
8. popitem()：删除并返回字典中的一个任意 (key, value) 元组。
9. update(dict2)：将字典 dict2 的 key-value 对更新到当前字典中。
10. setdefault(key, default=None)：获取指定 key 对应的 value，如果 key 不存在，则将 key 对应的 value 设置为 default。

三、数据转换

1.保留位数

int 取整，round 4舍5入

# 取整
a = 3.14
b = 3.78
print(int(a))
print(int(b))

3
3

# 保留2位小数
n = 1.5555
a="%.2f"%n  #%代表格式化输出，.2代表小数点后保留两位，f代表数据类型是浮点型
b = round(float(n),2) #将a通过round函数处理后赋值给a1，传入的2代表保留两位小数
print(type(a),a)
print(type(b),b)

 1.56
 1.56

2.数字-字符串

# 1.直接转化
aa= 10.20
print('直接转化',str(aa))
# 2.保留精度
aa= 10.20
print('保留精度',str("%.2f"%aa))

直接转化 10.2
保留精度 10.20

3.字符串拼接

# 加号（+）拼接字符串。
str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result)  # 输出：Hello World

Hello World

# 格式化字符串拼接
name = "Alice"
age = 25
result = f"My name is {name} and I am {age} years old."
print(result)  # 输出：My name is Alice and I am 25 years old.

My name is Alice and I am 25 years old.

# %s拼接
name = "Alice"
age = 28
message = "My name is %s and I am %d years old." % (name, age)
print(message) # 输出: My name is Alice and I am 28 years old.

My name is Alice and I am 28 years old.

# format拼接
name = "Alice"
age = 28
message = "My name is {} and I am {} years old.".format(name, age)
print(message) # 输出: My name is Alice and I am 28 years old.

My name is Alice and I am 28 years old.

4.列表-字符串

# join方法默认无连接符
my_list = ['apple', 'banana', 'orange']
my_string = ' '.join(my_list)
my_string2 = ','.join(my_list)
print(type(my_string),my_string) 
print(type(my_string2),my_string2) 

 apple banana orange
 apple,banana,orange

5.字符串-列表

# split分割字符串,默认空格
my_string = "apple banana orange"
my_list = my_string.split()
print(type(my_list),my_list)  # 输出: ['apple', 'banana', 'orange']

 ['apple', 'banana', 'orange']

# list()函数分割字符串
my_string = "hello"
my_list = list(my_string)
print(type(my_list),my_list)   # 输出: ['h', 'e', 'l', 'l', 'o']

 ['h', 'e', 'l', 'l', 'o']

# eval处理字符串中表达式
my_list = ['apple', 'banana', 'orange']
str1 = str(my_list)
s2 = eval(str1)
print(type(str1),str1)
print(type(s2),s2)

 ['apple', 'banana', 'orange']
 ['apple', 'banana', 'orange']

# split处理字符串
msg = 'hello----world'
ma = msg.split('-')
mb = filter(None, msg.split('-'))
print(type(ma),ma)
print(type(mb),mb)
for m in mb:
    print(m)

 ['hello', '', '', '', 'world']
 
hello
world

6.列表或元组-字典

l1 = ['a','b','c','d']
l2 = (1,2,3,4)
z = zip(l1,l2)
d = dict(z)
print(type(d),d)

 {'a': 1, 'b': 2, 'c': 3, 'd': 4}

7.dict转换为obj对象

class Dict2Obj(dict):

    def __getattr__(self, key):
        return self.get(key)

    def __setattr__(self, key, value):
        self[key] = value

d =   {'a': 1, 'b': 2, 'c': 3, 'd': 4}
do = Dict2Obj(d)
print(type(do),do)
print(type(do.a),do.a)  # dict字段是.get('a')

 {'a': 1, 'b': 2, 'c': 3, 'd': 4}
 1

8.两个字典的异同

a = {
    "x":1,
    "y":2,
    "z":3
}
b = {
    "x":1,
    "w":11,
    "z":12
}
# 查看字典a和字典b相同的键值对
print(a.items() & b.items())
# 查找所有差异
differ = set(a.items()) ^ set(b.items())
print(differ)
print(dict(differ))

{('x', 1)}
{('w', 11), ('y', 2), ('z', 3), ('z', 12)}
{'w': 11, 'y': 2, 'z': 12}

四、排序

1.列表排序

.sort 改变列表，sorted() 生成新的列表

# .sort排序,默认升序
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort() # 升序
print(numbers)  
numbers.sort(reverse=True) # 降序
print(numbers)  

 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
[9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

# .sort排序,按字符串长度排序并打印结果
words = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']
words.sort(key=len)
print(words)

['date', 'fig', 'apple', 'banana', 'cherry', 'elderberry']

numbers = [5, 3, 8, 4, 2]
sorted_numbers = sorted(numbers)  # 升序排序
print(sorted_numbers) 
reverse_numbers = sorted(numbers, reverse=True)  # 降序排序
print(reverse_numbers)  

 [2, 3, 4, 5, 8]
 [8, 5, 4, 3, 2]

2.字典排序

Python 3.6 之后字典是可以排序的

dic={'a': 4, 'b': 3, 'd': 1, 'c': 2}
dt = sorted(dic.items(), key=lambda x: x[1],reverse=True)
ds = dict(dt)
print(type(dt),dt)
print(type(ds),dict(ds))

 [('a', 4), ('b', 3), ('c', 2), ('d', 1)]
 {'a': 4, 'b': 3, 'c': 2, 'd': 1}

3.列表内嵌套字典的排序

# 按照score的大小排序
students = [
   {"name": "Tom", "score": 92},
   {"name": "Jack", "score": 85},
   {"name": "Lucy", "score": 87},
   {"name": "Marry", "score": 99}
]
sorted_students = sorted(students, key=lambda x: x["score"], reverse=True)
print(type(sorted_students),sorted_students)

 [{'name': 'Marry', 'score': 99}, {'name': 'Tom', 'score': 92}, {'name': 'Lucy', 'score': 87}, {'name': 'Jack', 'score': 85}]

# 先按score升序，再按age降序
students = [
	{'name': 'Jack', 'age': 17, 'score': 89},
	{'name': 'Julia', 'age': 17, 'score': 80}, 
	{'name': 'Tom', 'age': 16, 'score': 80}
 ]
students.sort(key=lambda student: (student['score'], -student['age']))
print(students)

[{'age': 17, 'score': 80, 'name': 'Julia'}, {'age': 16, 'score': 80, 'name': 'Tom'}, {'age': 17, 'score': 89, 'name': 'Jack'}]

4.反转字符串/列表

递归的方式可能存在深度限制，sys.getrecursionlimit()默认1000,

mstr = 'abc'
ml = [1,2,3]
mstr[::-1]
ml[::-1]

'cba'
[3, 2, 1]

ml = [1,2,3,4,5]
ml.reverse()
print(ml)

[5, 4, 3, 2, 1]