Python数据类型

字符串

在 Python 中，字符串（String） 是表示文本数据的基本数据类型，由字符序列组成。以下是关于 Python 字符串的定义和用法的详细说明：

字符串的定义

基本定义
- 使用 单引号 ' ' 或 双引号 " " 包裹文本：
```
s1 = 'Hello'
s2 = "Python"
```
- 三引号 ''' ''' 或 """ """ 用于定义多行字符串：
```
s3 = '''这是一个
多行
字符串'''
```
转义字符
- 使用 \ 转义特殊字符：
```
s = "He said, \"Hello!\""
```
- 常见转义字符：\n（换行）、\t（制表符）、\\（反斜杠）等。
原始字符串
- 在字符串前加 r 或 R，忽略转义：
```
path = r"C:\new_folder\file.txt"
```

字符串的遍历

buf = "nihao-woshi-yifan"

# 正向遍历
for i in range(len(buf)):
    print(f"{i}-{buf[i]}")

# 反向遍历
for i in range(len(buf)-1,-1,-1):	# 计算机是从零开始计数的；左闭右开，第二位数也必须为-1
    print(f"{i}-{buf[i]}")

字符串的切片

用法：容器[(开始索引):(结束索引)(:(步长))]

string[start:end:step]	# 区间前闭后开
# string :表示要截取的字符串（字符串容器）   
# start ：表示要截取的第一个字符的索引（包括该字符），不指定，默认为0
# end：表示要截取的最后一个字符的索引（不包括该字符），不指定，默认为字符串的长度
# step：表示切片的步长，若省略，默认为1。当省略该步长时，最后一个冒号也可以省略。

res = buf[0:len(buf)]    # 切片所有字符串的一般写法
res = buf[::]

# 倒序
res = buf[-1:-len(buf)-1:-1] # 传统倒序
res = buf[-1::-1]	# 中间什么也不写默认为所有（无终点）
res = buf[::-1]		# 都不写，无起点终点，直接全部包含（标准字符串倒序输出）※

# 判断回文数
buf = "abcba"
res = buf[::-1]
print(res == buf)

切片就算超过了字符串的索引范围也不会报错的

字符串的方法

类型判断 - 9

string.isspace()如果 string 中只包含空格（换行、制表符），则返回 True

※string.isalnum()如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True

※ string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True

※ string.isdecimal()如果 string 只包含数字则返回 True. 全角数字

string.isdigit()如果 string 只包含数字则返回 True. 全角数字、⑴ 、\u00b2

string.isnumeric()如果 string 只包含数字则返回 True. 全角数字，汉字数字

string.istitle()如果 string 是标题化的(指每个单词的首字母大写) 则返回 True

string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True

string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

查找和替换 - 7

string.startswith(str)检查字符串是否是以 str 开头，是则返回 True

string.endswith(str)检查字符串是否是以 str 结束，是则返回 True 用于判断文件后缀多一些

string.find(str,start=0,end=len(string))检测str是否包含在string中,如果start和end指定范围,则检查是否包含在指定范围,如果是,返回开始索引值,否则返回-1

string.rfind(str, start=0, end=len(string))类似于 find()，不过是从右边开始查找

string.index(str, start=0, end=len(string))跟 find() 方法类似，不过如果 str 不在 string 会报错，所以一般都会用 find()

string.rindex(str, start=0, end=len(string))类似于 index()，不过是从右边开始

string.replace(old_str, new_str, num=string.count(old))把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

大小写转换 - 5

string.capitalize()把字符串的第一个字符大写

string.title()把字符串的每个单词首字母大写

※string.lower()转换 string 中所有大写字符为小写

※string.upper()转换 string 中的小写字母为大写

string.swapcase()翻转 string 中的大小写

去除空白字符 - 3

string.lstrip()截掉 string 左边（开始）的空白字符

string.rstrip()截掉 string 右边（末尾）的空白字符

string.strip()截掉 string 左右两边的空白字符

拆分和连接 - 5

string.partition(str)把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)

string.rpartition(str)类似于 partition() 方法，不过是从右边开始查找

***string.split(str="", num)***以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格

string.splitlines()按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表

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

随机

导入模块包 random

import random

num1 = random.randint(1,6)	# 随机 1-6 整数
num2 = random.random()		# 随机(0,1)区间小数
num3 = random.uniform(1,2)	# 随机指定范围(1,2)区间小数

li = ["11","22","33"]
name = random.choice(li)	# 随机列表内容
print(name)

list = random.sample([i for i in range(1,34)],k=7)	# 随机从列表中取出7个不相同的数

列表

定义

由一系列变量组成的可变的有序序列容器

•

列表存放的是变量（各种类型）
•

可以对列表进行增删改查操作

特点

•

List（列表）是 Python 中使用最频繁的数据类型，在其他语言中通常叫做数组
•

专门用于存储一串信息
•

列表用[]定义，数据之间使用,分隔
•

列表的索引从0开始
•

索引就是数据在列表中的位置编号，索引又可以被称为下标

从列表中取值时超出索引范围，程序会报错

列表和字符串的异同

列表和字符串都是有序序列，元素之间有先后顺序关系

字符串是不可变的序列，列表是可变的序列

字符串中每个元素只能存储字符，而列表可以存储任意类型。

列表和字符串都是可迭代对象，都可以遍历（for循环）。

基础操作--几乎同字符串一致

# 创建
li = ["德华","天乐","富城","彦祖"]
print(li,type(li))

# 证明可变
li += li
print(li,id(li))	# 操作完内存地址不变

# 求最值
li2 = ["100","200","150","25"]
print(max(li2))
print(min(li2))
print(sum(li2))

# 遍历
for i in li:
    print(i)

# range
for i in range(0,len(li)):
    print(li[i])	#索引取值
    
# 反向遍历
for i in range(len(li)-1,-1,-1):	# 为什么减一？因为列表的索引下标从0开始的，所以索引最大值为len(li)-1；第二个-1是因为range左闭右开
    print(li(i))
    
# 切片，同字符串的切片
print(li[:])
print(li[::-1])

# 二维数组
li = ["刘德华","周星驰",["美人鱼","功夫","大话西游"],"达叔","张学友"]
print(li,type(li))
print(li[2][2])		# 取列表中的 大话西游

基础操作--列表的增删改查(重点，背过)


# 新增
li.append("")	# 在列表的末尾插入
li.insert(1,"")		# 在指定的索引前插入
li.extend(li2)		# 在列表li尾部追加新的列表li2


# 改
li[2] = "xxx"
print(li)

# 删除
li.pop()			# 默认删除列表中最后一个元素
li.pop(i)			# 删除列表中给定索引对应的元素，超出索引范围会报错
li.clear()			# 清除列表中所有的元素
li.remove("xxx")  # 删除给定的元素内容，只会删除第一次出现的对应元素
del li				# 一般不要用，会清除整个列表，包括其定义
del li[2]			# 一般不要用，同pop(i)
print(li)

# 查询
res = li[i]			# 根据索引下标返回对应的内容
res = li.index("rose")	# 根据内容返回对应的索引下标
print(res)

# 统计
res = li.count("xxx") # 统计给出的内容在列表中出现的次数
res = len(li)		# 获取列表的长度，为 n+1
print(res)

# 排序
res = li.sort()		# 排序，从小到大
res = li.sort(reverse=True)	# 排序，降序，从大到小
res = li.reverse()	# 逆序，反转，同 [::-1]
print(res)

高级操作--遍历列表

正向遍历

for 变量名 in 列表名:
    变量名  #就是元素

反向遍历

for 索引名 in range(len(列表名)-1,-1,-1):
    列表名[索引名]  #就是元素

深浅拷贝

浅拷贝

复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程

# 原始数据
li = ["汉堡","炸鸡","烤肠","可乐"]
print(li,id(li))

# 尝试=对数据进行备份
li2 = li	# 对原始数据进行拷贝
print(li2,id(li2))	# 此时li和li2的地址相同
li2[-1] = "炸蚂蚱"
print("这是处理后的数据li2：",li2)
print("这是处理后的数据li：",li)	# 因为li和li2的地址相同，所以一改全改		
# 正确的方法
li2 = li.copy()	# 浅拷贝
print(li2,id(li2))	# 此时li和li2的地址不再相同
li2[-1] = "炸蚂蚱"
print("这是处理后的数据li2：",li2)
print("这是处理后的数据li：",li)	# 因为li和li2的地址不同，所以对li2的更改与li没关系

深拷贝

复制整个依懒的变量

# 原始数据
li = ["馒头","咸菜",["鸡肉","面包片","番茄"],"饼子","稀饭"]
print(li,id(li))

# 对数据进行备份
li2 = li.copy()	# 浅拷贝
print(li2,id(li2))	
li2[-1] = "炸串"
print("这是处理后的数据li2：",li2)
print("这是处理后的数据li：",li)	# 虽然因为li和li2的地址不同，但是li和li2里面的第二层列表仍然共用，所以对第二层列表进行更改时仍会一改全改出问题

# 正确的做法
import copy
li2 = copy.deepcopy(li) # 深拷贝。
print(li2,id(li2))	# 此时li和li2的地址不再相同
li2[1][2] = "炸鸡"
print("这是处理后的数据li2：",li2)
print("这是处理后的数据li：",li)	# 因为li和li2的地址不同，所以对li2的更改与li没关系

为了数据的安全，备份列表一定要与深拷贝！！！

列表与字符串互转

# 列表转字符串
li = ["李师师","高圆圆","刘亦菲"]
# buf = str(li)		# 错误方法：强制转换
buf = "-".join(li)	# 以什么分隔符（这里是“-”）分割字符串  不能进行二维及以上的列表转换
print(buf,type(buf))

# 字符串转列表
buf2 = "杨幂-李师师-刘亦菲"
# result = list(buf2)	# 错误方法：强制转换
result = buf2.split("-")	# 字符串以什么分隔符（这里是“-”）分割的
print(result,type(result))

列表的生成式

li = [11,22,33,44,55,66,77,88,99]	#少的话可以这样，多的呢？

# 创建一个从1-10000个数的列表
# 列表的生成式 语法
li2 = [i for i in range(1,10001)]	# 第一个 i 控制输出
li2 = [i/2 for i in range(1,10001)]	# 0.5 1.0 1.5 2.0 2.5 3.0 ... 5000.0
li2 = [i+i for i in range(1,10001)]	# 2 4 6 8 10 ... 20000
li2 = [i for i in range(1,101) if i % 2 == 0]		#t可以添加if条件
# 本质
for i in range(1,101):
	if i%2 == 0:
        print(i)

# 列表的推导式
li4 = [i+c for i in range(1,21) for c in range(51,71)]
# 本质
for i in range(1,21):
    for c in range(51,71):
        print(i+c)

三元运算符

max = a if a>b else b
# 本质
max = none
if a>b:
    max=a
else:
    max=b

应用：去重

# 去重
# 方法1：
li = [11,22,44,33,33,22,22,11,55,66,55,33,11,88]
li2 = li.copy()
# for i in range(0,len(li)):
#     num=li2.count(li[i])
#     while num != 1:
#         li2.remove(li[i])
#         num -= 1
# li2.sort()
# print(li2)
for i in li2:
    result = li.count(i)
    while result > 1:
        li.remove(i)
        result = li.count(i)

# 方法2：
li = [11,22,44,33,33,22,22,11,55,66,55,33,11,88]
li2 = []
# for i in range(0,len(li)):
#     if li2.count(li[i]) == 0:
#         li2.append(li[i])
#     else:
#         continue
# li2.sort()
# print(li2)
for i in li:
    if i not in li2:
        li2.append(i)
print(li2)

# 方法3：用索引算法
li = [11,22,33,44,44,33,22,44,44,33,22,11]
num = 0
while num < len(li):
    num2 = num+1
    while num2 < len(li):
        if li[num] == li[num2]:
            li.pop(num2)
        else:
            num2 = num2 + 1
    num += 1
print(li)

# 方法4  利用set集合
li = [11,22,33,44,44,33,22,44,44,33,22,11]
li2 = list(set(li))
print(li2)

元组

由一系列变量组成的不可变的有序序列容器，以()包括，如果只有一个元素，则必须添加一个逗号，否则就不是元组

基本操作同字符串差不多

元组和列表的异同

•

元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素
•

元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
•

格式字符串，格式化字符串后面的（）本质上就是一个元组
•

让列表不可以被修改，以保护数据安全
•

元组可以进行“解包”操作，即name， age = ("名字",25) print(name,age)

字典

定义

msg = {
    key:value1,
    key2:value2,
    ...
}

dictionary（字典）是 除列表以外 Python 之中 最灵活 的数据类型

•

字典同样可以用来存储多个数据
- •
  
  通常用于存储描述一个物体的相关信息
•

和列表的区别
- •
  
  列表是有序的对象集合
- •
  
  字典是无序的对象集合

集合就意味着可以遍历

特性

字典使用键值对存储数据，键值对之间使用：分隔

键 key 是索引

值 value 是数据

键和值之间使用:分隔

键必须是唯一的

key 必须为不可变数据类型 （字符串、数字、元组）

值可以取任何数据类型，但键只能使用字符串、数字或元组

一个key对应的value可存放任意数据类型，可修改、可以不唯一

可嵌套，即value也可以是dict

py3.7之前是无序的，3.7开始变成有序的。ordered dict

查询速度快，且不受dict的大小影响。至于为什么快？需要了解hash O(1)

看到{}首先想到的是字典

操作

# 查询
print(dic["key1"]["key2"])	# 根据 key1 key2 键值从 dic 中查询数据
print(dic.get("key"))		# 根据 key 键值从 dic 中查询数据
	# get 方法如果没有取到对应的键值对，不会报错，返回 None 
print(dic.keys())			# 打印所有的 key 键，返回一个 字典键 类型，其无序但可以遍历
print(dic.values())			# 打印所有的 value 值，返回一个 字典值 类型，其无序但可以遍历
print(dic.items())			# 以元组形式打印所有的 键值对

# 增加 和 修改
dic["key3"] = "value3"		# 新增后字典为{"key1":"value1","key2":"value2","key3":"value3"}
dic["key2"] = "value4"		# 修改后字典为{"key1":"value1","key2":"value4","key3":"value3"}
	# 增加和修改 如果有这个键就对该键对应的值进行修改，如果没有这个键就新增。

# 新增
dic.setdefault(key,value)	# 如果有这个键就不修改修改，如果没有这个键就新增
# 修改
dic1.update(dic2)			# 将字典2中的数据合并到字典1中

# 删除
dic.pop("key1")				# 删除指定键值对应的键值对，如果没有会报错，删除后字典为{"key2":"value2","key3":"value3"}
dic.popitem()				# 3.7 之前是随机删除一个键值对，3.7之后是删除最后一个键值对
dic.clear()					# 清空字典数据

# 浅拷贝
dic.copy()					# 同列表的 copy 一样

循环遍历

for k in dic.keys(): 

for k,v in dic.items(): 

for k in dic:

字典推导式

使用简易方法，将可迭代对象转换为字典

{键:值 for 变量 in 可迭代对象}

{键:值 for 变量 in 可迭代对象 if 条件}

字典（哈希算法） VS 列表

•

都是可变容器。
•

获取元素方式不同,列表用索引,字典用键。
•

字典的插入,删除,修改的速度快于列表。
•

列表的存储是有序的,字典的存储是无序的。

字典-hash

因为dict 是基于 hashtable 实现的，hashtable 的原理导致你查询速度就是O(1)，意思就是你即使有1亿个数据，查询某个值也是1. 字典是 python 中唯一的一个映射类型，他是以{}括起来的键值对组成，在 dict 中 key 是唯一的，在保存的时候，根据key来计算出一个内存地址，然后将key-value保存在这个地址中，这种算法被称为 hash 算法，所以切记，在 dict 中存储的 key-value 中 key 必须是可 hash 的

可以改变的都是不可哈希的

已知的可哈希（不可变）的数据类型： int ，str , tuple ，bool 不可哈希（可变）的数据类型： list,dict，set

字典的key必须是可哈希的，不可变的，value没有限制由一系列键值对组成的可变映射容器

映射：一对一的对应关系，且每条记录无序

集合

定义

集合跟我们学的列表有点像，也是可以存放一堆数据

不过集合有几个独特的特点，令其在整个Python语言中占有一席之地。相当于只有键没有值的字典（键则是集合的数据)。

•

里面的元素不可变，代表不能存储一个list、dict、
•

在集合中，字符串、数字、元组等不可变类型可以存。
•

天生自带去重，在集合中没有办法存储重复的元素。
•

无序、不像列表一样通过索引来标记在列表中的位置，元素是无序的，集合的元素无先后之分，如集合{2，3，4}和{3.2,4}算作相同集合。

很少会去用集合来循环

作用

去重和关系运算

用法

# 定义
set = {key1,key2,key3...}

可变的：list dict set

不可变的：number str tuple

posted on 2025-04-08 19:57 爱姬多娜阅读(104) 评论(0) 收藏举报

刷新页面返回顶部

echidna