4、python内置数据结构---字符串、列表、元组、集合、字典
目录
一、字符串str
1、字符串的创建和赋值
1.1字符串的定义
1.2常用转义符号
1.3三重引号详解
2、字符串的基本特性
2.1连续操作符和重复操作符
2.2成员操作符
2.3正向索引和反向索引
2.4切片
2.5for循环访问
2.6练习题
3、字符串的内建方法
3.1字符串的判断与转换
3.2字符串的开头和结尾匹配（常用于判断文件类型）
3.3字符串的数据清洗
3.4字符串的位置调整
3.5字符串的搜索、统计
3.6字符串的分离与拼接
4、有关字符串的练习题
4.1ip检测器
4.2小学生能力测试
4.3学生出勤记录
4.4机器人能否返回原点
二、列表（list）
1、列表的创建
2、列表的基本特性
3、列表的常用方法（增删改查）
三、元组
1、元组的操作
2、命名元组的操作
四、集合
1、集合的操作
2、集合的练习
五、字典
1、字典的操作
2、默认字典
六、深拷贝与浅拷贝
七、相关练习题
1、云主机操作
2、两数之和
3、无重复字符串
八、内置数据结构总结
一、字符串str
1、字符串的创建和赋值
1.1字符串的定义
字符串或串(String)是由数字、字母、下划线组成的一串字符。Python 里面最常见的类型。 可以简单地通过在引号间(单引号,双引号和三引号)包含字符的方式创建它。
1.2常用转义符号
| \n | 换行符（用于输出） |
| \t | 水平制表符（Tab键）（用于输出） |
| \\ | 反斜杠字符 （用来表示一个反斜杠字符） |
| \' | 单引号（用来表示一个单引号字符） |
（全面）：
1.3三重引号详解
作用一：进行多行注释 ，Python中单行注释是#，多行注释的时候每行都写一个#，或者采用连续的三个双引号
作用二：定义多行字符串 ，为避免使用转义换行符 \n，通常会用在定义SQL语句的表达式中没有变量的时候使用。
2、字符串的基本特性
2.1连续操作符和重复操作符
连接操作符： 从原有字符串获得一个新的字符串
重复操作符: 创建一个包含了原有字符串的多个拷贝的新串
2.2成员操作符
成员操作符用于判断一个字符或者一个子串(中的字符)是否出现在另一个字符串中。出现则返回 True,否则返回 False
2.3正向索引和反向索引
索引(s[i] )：获取特定偏移的元素
索引的分类: 正向索引, 反向索引
2.4切片
2.5for循环访问
2.6练习题
3、字符串的内建方法
3.1字符串的判断与转换
title: 标题需要每一个首字母大写，e.g. Hello Python
space: 空格指的是广义的空格， e.g: \n, \t, 
3.2字符串的开头和结尾匹配（常用于判断文件类型）
3.3字符串的数据清洗
3.4字符串的位置调整
3.5字符串的搜索、统计
s = 'hello westos'
s.find('llo') find如果找到子串，则返回子串开始的索引位置
2
s.find('ll0') find如果找不到子串，则返回-1
-1
s.index('ll0')
Traceback (most recent call last):
File "", line 1, in
ValueError: substring not found index如果找不到子串，则报错
s.index('llo') index如果找到子串，则返回子串开始的索引位置
2
s.count('l') 检测l在hello world中出现的次数
2
3.6字符串的分离与拼接
4、有关字符串的练习题
4.1ip检测器
while True:
ip = input('请输入一个有效的ip地址：')
ip_list = ip.split('.')
flage = True
if ip.count('.') == 3 and len(ip_list) == 4:
flage = True
if ip_list[0].isdigit() and int(ip_list[0]) >= 1 and int(ip_list[0]) <= 255:
flage = True
for i in range(1,4):
if ip_list[i].isdigit() and int(ip_list[i]) >= 0 and int(ip_list[i]) <= 255:
flage = True
else:
flage = False
else:
flage = False
else:
flage =False
if flage == True:
print(f'{ip}是一个有效的ip地址')
else:
print(f'{ip}不是一个有效的ip地址')
4.2小学生能力测试 
import random
count = 10
correct = 0
for i in range(10):
num1 = random.randint(1,10)
num2 = random.randint(1,10)
symbol = random.choice(['+','-','*'])
question = f"{num1}{symbol}{num2}=?"
print(question)
value = eval(f"{num1}{symbol}{num2}")
answer = int(input('请输入你的答案：'))
if answer == value:
print('True')
correct += 1
else:
print('False')
Turepercent = correct/count*100
print('你的正确率为%.2f%%'%(Turepercent))4.3学生出勤记录
4.4机器人能否返回原点
print("""-----------机器人能否返回原点测试-----------
提示：R(右) L(左) U(上) D(下)
""")
while True:
operator = input('请输入你的操作：')
start = [0,0]
level = 0
vertical = 0
count = 0
for item in operator:
if item == 'R':
level += 1
flage = True
elif item == 'L':
level -= 1
flage = True
elif item == 'U':
vertical += 1
flage = True
elif item == 'D':
vertical -= 1
flage = True
else:
print('请输入正确的操作!')
flage = False
count +=1
position = [level,vertical]
if position == start and flage != False:
print('可以返回原点')
elif position != start and flage != False:
print('不可以返回原点')
二、列表（list）
1、列表的创建
list = [1,2,1.2,'hello','nice to']
print(list)
结果：
[1, 2, 1.2, 'hello', 'nice to']2、列表的基本特性
1.连接操作符和重复操作符
print([1,2]+[2,3])
print([1,2]*3)
结果:
[1, 2, 2, 3]
[1, 2, 1, 2, 1, 2]2.成员操作符
print(1 in [1,2])
print(1 in ['a',True,[1,2]])
print(1 in ['a',False,[1,2]])
#bool类型：True=1 False=0
结果:
True
True
False3.索引
list = [1,2,3,[1,'b',3]]
print(list[0])
print(list[-1])
print(list[-1][1]) #-1里面的1
print([3][-1])
结果：
1
[1, 'b', 3]
b
34.切片
list = ['172','23','12','5']
print(list[:2])
print(list[1:])
print(list[::-1])
print('-'.join(list[3:0:-1]))
print('-'.join(list[1:][::-1]))
结果:
['172', '23']
['23', '12', '5']
['5', '12', '23', '172']
5-12-23
5-12-23
5. for循环
names = ['1','2','3']
for name in names:
print(f"name{name}")
结果：
name1
name2
name33、列表的常用方法（增删改查）
1.增加
list = [1,2,3]
1.1 追加
list.append(4)
print(list) #[1, 2, 3, 4]
1.2 列表指定位置添加
list.insert(0,'cat')
print(list) #['cat', 1, 2, 3, 4]
list.insert(1,'dog')
print(list) #['cat', 'dog', 1, 2, 3, 4]
1.3 一次追加多个元素
list.extend([4,5,6])
print(list) #['cat', 'dog', 1, 2, 3, 4, 4, 5, 6]
2.修改
li = [1,2,3]
li[0] = 'cat'
print(li)
li[2] = 'dog'
print(li)
li[:2] = [1,1]
print(li)
结果:
['cat', 2, 3]
['cat', 2, 'dog']
[1, 1, 'dog']
3.查看 通过索引和切片查看元素，查看索引值和出现次数
li = [1,2,3,1,2,3,4,1]
print(li.count(1)) #3
print(li.index(4)) #64.删除
4.1 根据索引删除
li = [1,2,3]
delete_num = li.pop(-1)
print(li) #[1, 2]
4.2 根据value值删除
li = [1,2,3]
li.remove(3)
print(li) #[1, 2]
4.3 全部清空
li = [1,2,3]
li.clear()
print(li) #[]
其他操作
1.反转
li = [1,2,3,4]
li.reverse()
print(li) #[4, 3, 2, 1]
2.排序
sort排序默认由小到大，如果想由大到小排序，设置reverse=True
li.sort()
print(li) #[1, 2, 3, 4]
li.sort(reverse=True)
print(li) #[1, 2, 3, 4]
3.复制，id不同
li1=li.copy()
print(li,li1) #[4, 3, 2, 1] [4, 3, 2, 1]
print(id(li),id(li1)) #2239037465160 2239037465224
4.直接删除li列表
del li
三、元组
1、元组的操作
0.元组简单示例
tuple1=(1,2.2,'cas',[1,2,3])
print(tuple1) #(1, 2.2, 'cas', [1, 2, 3])
1.元组的创建
t1 = () #空元组
print(t1,type(t1)) #()
t2 = (1,) ##重点：元组单个元素一定要加逗号
print(t2,type(t2)) #(1,)
2.元组的特性
2.1连接操作符和重复操作符
print((1,2,3)+(4,)) #(1, 2, 3, 4)
print((1,2,3)*3) #(1, 2, 3, 1, 2, 3, 1, 2, 3)
2.2成员操作符
print(1 in (1,2,3)) #True
2.3切片
t = (1,2,3)
print(t[0]) #1
print(t[:]) #(1,2,3)
print(t[-1]) #3
print(t[::-1]) #(3,2,1)
print(t[:2]) #(1,2)
print(t[1:]) #(2,3)
3.常用方法
count和index，元组是不可变类型，不能增删改查
t = (1,2,3,4,1,1)
print(t.count(1)) #3
print(t.index(2)) #1
注意：！！！（1）不是元组，（1，）才是元组
2、命名元组的操作
- Tuple还有一个兄弟，叫namedtuple。虽然都是tuple，但是功能更为强大。
collections.namedtuple(typename, field_names)
typename：类名称
field_names: 元组中元素的名称
tuple = ('yxy',18,'西安') #普通元组
命名元组解决了读代码的烦恼
from collections import namedtuple
1.创建命名元组对象User
User = namedtuple('User',('name','age','city'))
2.给命名元组传值
user1 = User('yxy',18,'西安')
3.打印命名元组
print(user1) #User(name='yxy', age=18, city='西安')
print(user1.name) #yxy
print(user1.age) #18
print(user1.city) #西安
四、集合
1、集合的操作
- 集合（set）是一个无序的不重复元素序列。1,2,3,4,1,2,3 = 1,2,3,4
集合的创建:
1). 使用大括号 { } 或者 set() 函数创建集合;
2). 注意：
创建一个空集合必须用 set() 而不是 { }
{ } 是用来创建一个空字典。
0.set集合简单操作
set1 = {1,2,3,5}
set2 = {2,3,4}
print("交集：",set1 & set2) #交集： {2, 3}
print("并集：",set1 | set2) #并集： {1, 2, 3, 4, 5}1.集合的创建
s = {1,2,3,1,2,3}
print(s,type(s)) #{1, 2, 3}
注意:
· 集合的元素必须是不可变数据类型
s = {1,2,[1,2]}
print(s,type(s)) TypeError: unhashable type: 'list'
· 空集合不能使用{},而要使用set()
s = set()
print(s,type(s)) #set()
2.集合的特性：不重复无序的
'''
不支持+ , * ,index , slice(切片)
支持in 和 not in 成员操作符
'''
s = {1,2,3,4}
print(1 in s) #True3.集合的常用方法
3.1 增加:
s = {1,2,3}
s.add(100) #add添加单个元素
print(s) #{1, 2, 3, 100}
s.update('456') #update添加多个元素
print(s) #{1, 2, 3, 100, '6', '4', '5'}
s.update({4,5,6})
print(s) #{1, 2, 3, 100, 4, 5, '6', 6, '5', '4'}
3.2 删除：
'''
remove，如果元素存在删除，否则报错
discard，如果元素存在删除，否则不做任何操作
pop，随机删除一个元素，集合为空报错
'''
s = {1,2,3}
s.remove(1)
print(s) #{2，3}
s.discard(2)
print(s) #{3}
s.discard(10)
print(s) #{3}
s = {1,2,3,4}
s.pop()
print(s) #{2,3,4}
3.3 查看
差集s1-s2,交集s1&s2，对称差分s1^s2，并集s1|s2
s1 = {1,2,3}
s2 = {1,2}
print(s1-s2) #{3}
print(s1&s2) #{1, 2}
print(s1|s2) #{1, 2, 3}
对称差分（并集-交集）
s1 = {1,2,3}
s2 = {1,2,4}
print(s1^s2) #{3, 4}
子集
sa = {1,2,3,4}
sb = {1,2}
print(sb.issubset(sa)) #True b是a的子集嘛
print(sb.isdisjoint(sa)) #False 两者没有交集嘛
print(sa.issuperset(sb)) #True a是b的父集嘛
4. 排序
s = {1,42,55,2,3,5,8,34}
sorted(s)
print(s)
5. 拓展：frozenset不可变集合
s = frozenset({1,2,3})
print(s,type(s))
#frozenset({1, 2, 3})
2、集合的练习
import random
N = int(input('请输入生成随机数的个数：'))
s = set()
for i in range(N):
num = random.randint(1,1001)
s.add(num)
s = sorted(s,reverse=True)
print(s)五、字典
1、字典的操作
定义：
字典是另一种可变容器模型，且可存储任意类型对象。
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一1.字典的创建dict
key-value对或键值对
dict1 = {"name":"wl","age":"21","city":"tc"}
print(dict1,type(dict1)) #{'name': 'wl', 'age': '21', 'city': 'tc'}
print(dict1["name"]) #wl
2.字典的特性：无序不重复
不支持+ , * ,index , slice(切片)
支持in 和 not in 成员操作符(主要是判断key值)
dict1 = {"name":"wl","age":"21","city":"tc"}
print("name" in dict1) (判断是否为所有key值的成员)True
print("xa" in dict1) False
print("wl" in dict1) False
3.字典的常用方法
3.1查看
"""
查看所有: keys,values,items
查看局部: d[keys],d.get()
"""
操作:
dict1 = {"name":"wl","age":"21","city":"tc"}
print(dict1.keys()) #查看字典所有的key值
print(dict1.values()) #查看你字典所有的values值
print(dict1.items()) #查看字典的item元素
print(dict1['name']) #查看key-name对应的value值
#print(dict1['province']) #查看key不存在的会报错
print(dict1.get('provience')) #获取查看key对应的value值，如果存在则返回，不存在返回None。
print(dict1.get('province','shanxi')) #获取查看key对应的value值，如果存在则返回，不存在返回默认值shanxi 。
dict1 = {"name":"wl","age":"21","city":"tc","provience":"shanxi"}
print(dict1.get("provience"))
结果：
dict_keys(['name', 'age', 'city'])
dict_values(['wl', '21', 'tc'])
dict_items([('name', 'wl'), ('age', '21'), ('city', 'tc')])
wl
None
shanxi
shanxi
3.2增加和修改
update添加多个元素
操作:
dict1 = {"name":"wl","age":"22"}
dict1["city"] = "西安" #key 不存在则添加
print(dict1)
dict1["city"] = "北京" #key 存在则修改
print(dict1)
dict2 = {"name":"wl","age":"11"}
dict2.setdefault("city","西安") #key不存在则添加
print(dict2)
dict2.setdefault("city","北京") #key存在则不做任何操作
print(dict2)
结果：
{'name': 'wl', 'age': '22', 'city': '西安'}
{'name': 'wl', 'age': '22', 'city': '北京'}
{'name': 'wl', 'age': '11', 'city': '西安'}
{'name': 'wl', 'age': '11', 'city': '西安'}
3.3 删除pop和del常用，popitem随机删除不常用
操作：
dict1 = {"name":'wl',"age":'10'}
dict1.pop("name")
print(dict1)
dict2 = {"name":'wl',"age":'10'}
del dict2["age"]
print(dict2)
结果：
{'age': '10'}
{'name': 'wl'}
3.4遍历字典
操作:
dict1 = {"name":'wl',"age":"10","city":"xian"}
默认情况下，指挥遍历key
for item in dict1:
print(dict1)
如何遍历字典的key和value呢？重要！！
for item in dict1.items():
print(item)
for key,value in dict1.items():
print(f"key={key},value={value}")
结果：
name
age
city
('name', 'wl')
('age', '10')
('city', 'xian')
key=name,value=wl
key=age,value=10
key=city,value=xian
2、默认字典
什么是默认字典？
from collections import defaultdict
d = defaultdict(int)
d["aaa"] += 1
d["ooo"] += 1
print(d)
d1 = defaultdict(list)
d1["allow_user"].append("yxy")
d1["deny_user"].append("gyh")
print(d1)
d2 = defaultdict(set)
d2["movies"].add("你好，李焕英")
d2["movies"].update({"人潮汹涌"})
print(d2)
结果：
defaultdict(, {'aaa': 1, 'ooo': 1})
defaultdict(, {'allow_user': ['yxy'], 'deny_user': ['gyh']})
defaultdict(, {'movies': {'你好，李焕英', '人潮汹涌'}})
六、深拷贝与浅拷贝
深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）注意：列表中含有可变数据类型时，一定要用深拷贝
1.值的引用
赋值： 创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。(=)
num1 = [1,2,3]
num2 = num1 #此时指向同一个内存空间
print(num2) #[1, 2, 3]
num1.append(4)
print(num1) #[1, 2, 3, 4]
print(num2) #[1, 2, 3, 4]
2.浅拷贝
n1 = [1,2,3]
n2 = n1.copy() ##n1.copy和ni[:]都可以实现拷贝
print(id(n1),id(n2)) ##copy指向不同的内存空间，所以互不影响
n1.append(4)
print(n1) ##相当于打印一份，然后在一份上做修改，不影响另一份
print(n2)
结果：
2813399097928 2813399097992
[1, 2, 3, 4]
[1, 2, 3]
3.深拷贝
"""
如果列表的元素包含可变数据类型，一定要使用深拷贝
可变数据类型(可增删改的): list
不可变数据类型(变量指向的内存空间的值不会改变): str,tuple,nametuple
"""
n1 = [1,2,[1,2]]
n2 = n1.copy()
#查看n1和n2的内存地址，发现进行了拷贝
print(id(n1),id(n2)) #2640188957320 2640192640200
#n1[-1]和n2[-1]的内存地址
print(id(n1[-1]),id(n2[-1])) #2640188957256 2640188957256
n1[-1].append(4)
print(n1) #[1, 2, [1, 2, 4]] 修改成功
print(n2) #[1, 2, [1, 2, 4]]，也随之改变
4. 如何实现深拷贝copy.deepcopy
"""
深拷贝： 一个变量对另外一个变量的值拷贝。(copy.deepcopy())
两个变量的内存地址不同；
两个变量各有自己的值，且互不影响；
对其任意一个变量的值的改变不会影响另外一个；
"""
import copy
n1 = [1,2,[1,2]]
n2 = copy.deepcopy(n1)
#查看n1和n2地址，发现进行了拷贝
print(id(n1),id(n2)) #2468787314632 2468787360264
#n1[-1]和n2[-1]的内存地址
print(id(n1[-1]),id(n2[-1])) #2468787204488 2468787360712
n1[-1].append(4)
print(n1) #[1, 2, [1, 2, 4]]修改成功
print(n2) #[1, 2, [1, 2]]
七、相关练习题
1、云主机操作
menu = """
云主机管理系统
1). 添加云主机
2). 搜索云主机(IP搜索)
3). 删除云主机
4). 云主机列表
5). 退出系统
请输入你的选择:"""
from collections import namedtuple
hosts = []
Host = namedtuple('Host',('hostname','ip','IDC'))
while True:
choice = input('请输入你的选择：')
if choice == '1':
print('添加云主机'.center(50,'-'))
ip = input('请输入ip地址：')
hostname = input('请输入主机名称：')
idc = input('请输入IDC：')
host1 = Host(ip,hostname,idc)
hosts.append(host1)
print(f'云主机添加成功，ip为{ip}')
elif choice == '2':
print('搜索云主机（以IP进行搜索）'.center(50,'-'))
for host in hosts:
ipv4 = input('请输入需要搜索的ip地址：')
if ipv4 == host.ip:
print(f'{ipv4}的主机名为{host.hostname}')
else:
print(f'未找到云主机{host.ip}')
elif choice == '3':
print('删除云主机'.center(50,'-'))
for host in hosts:
delete_hostname = input('请输入需要删除的云主机名称：')
if delete_hostname == host.hostname:
hosts.remove(host)
print(f'云主机{host}已删除')
else:
print('操作不成功')
elif choice == '4':
print('云主机列表'.center(50,'-'))
print("IP\t\t\t\thostname\t\t\t\tIDC")
count = 0
for host in hosts:
print(f'{host.hostname}\t{host.ip}\t\t\t{host.IDC}')
count += 1
print(f'云主机的个数是{count}')
elif choice == '5':
print('正在退出系统，欢迎下次使用')
break
else:
print('请输入正确的选项')
break2、两数之和
方法一：
li = [8,2,9,10,6]
target = int(input('请输入目标值：'))
n = len(li)
for i in range(n):
for j in range(i+1,n):
if target == li[i] + li[j]:
print(f'{i} {j}')
3、无重复字符串
八、内置数据结构总结
可变数据类型：列表、集合、字典
不可变数据类型：数值类型、元组、字符串
