python(三)--内置数据结构--字符串列表元组集合字典
1. 字符串str1.1 创建和赋值- 单引号，双引号三引号引起来的文字s1 = 'hello's2 = "hello"s3 = """1234325werasfasfa"""print(s1,s2,s3)## 转义，重点就是换行符和制表符>>> s = "hello\nwestos"##\n换行符>>> print(s)hellowestos>>&
·
目录
1. 字符串str
1.1 创建和赋值
- 单引号，双引号三引号引起来的文字
s1 = 'hello' s2 = "hello" s3 = """ 1234325werasfasfa """ print(s1,s2,s3) ## 转义，重点就是换行符和制表符 >>> s = "hello\nwestos" ##\n换行符 >>> print(s) hello westos >>> s = "hello\twestos" ##\t制表符 >>> print(s) hello westos
- 一个反斜线加一个单一字符可以表示一个特殊字符，通常是不可打印的字符
1.2 字符串的基本特性
1.2.1 连接操作符与重复操作符
# 1. 连接操作符+和重复操作符* name = 'westos' print('hello '+ name) # hello westos print('*'*10) # **********
1.2.2 成员操作符
# 2. 成员操作符in s = 'hello westos' print('westos' in s ) # True print('westos' not in s) #False
1.2.3 正向索引和反向索引
# 3.正向索引和反向索引 s = 'westos' print(s[1]) #e print(s[-3]) #t
1.2.4 切片
# 4.切片 """ 回顾： range(3) 返回123 range(1,6,2) 返回135 切片：切除一部分的内容，从0开始 s[start:end:step] s[:end] s[start:] 切片总结： s[:n] 拿出前n个元素 s[n:] 除了前n个元素，其他元素保留 s[:] 从头开始到结尾，显示全部内容 s[::-1] 倒叙 """ s = 'hello westos' print(s[1:3]) #el print(s[:3]) #hel print(s[:5]) #hello print(s[1:]) #ello westos print(s[:]) #hello westos，相当于拷贝字符串 print(id(s)) #12806168 s1 = s[:] print(id(s1)) #12806168 print(s[::-1]) #倒叙 sotsew olleh
1.2.5 可迭代对象/for循环
# 5.for循环访问 s = "westos" count=0 for item in s : count+=1 print(f"第{count}个元素: {item}") ##答案 第1个元素: w 第2个元素: e 第3个元素: s 第4个元素: t 第5个元素: o 第6个元素: s
1.2.6 练习
练习题: 用户输入一个字符串， 判断该字符串是否为回文字符串。 eg: "aba"是回文字符串, "abba"也是回文字符串。 "abc"不是回文字符串。#法一： while True: str1 = input("please input string:") if str1[:] == str1[::-1]: print(f"{str1} 是回文字符串！") else: print(f"{str1} 不是回文字符串！") # 法二： s = input("please input string:") result = "回文字符串" if s == s[::-1] else "不是回文字符串" print(s + '是' + result)
1.3 字符串的内建方法
1.3.1 字符串的判断与转换
类型的判断
s= 'Hello WESTos' print(s.isalnum()) #False,中间有空格 print(s.isdigit()) #False,是否数字 print(s.isalpha()) #False,是否字母
类型的转换
print('hello'.upper()) #HELLO #转换成大写 print('hellO'.lower()) #hello #转换成小写 print('hello'.title()) #Hello #开头大写 print('hello'.capitalize()) #Hello #首字母大写，其他小写 print('hello'.swapcase()) #HELLO #大小写呼唤
需求：用户输入Y或者y都继续执行代码
chose = input('是否继续安装程序Y或y:') if chose.lower() == 'y': print('正在安装程序。。。。')
1.3.2 字符串的开头和结尾的匹配
#1. startswith 以什么开头 url='http://www.baidu.com' if url.startswith('http'): print(f"{url} 是一个正确的网址，可以爬取网站的代码") else: print(f"{url} 不是一个正确的网址，可以爬取网站的代码") ##运行结果 http://www.baidu.com 是一个正确的网址，可以爬取网站的代码
#2. endswith 以什么结尾 #常用场景，判断文件的类型 filename = 'hello.png' if filename.endswith('.png'): print(f"{filename} 是一个图片") elif filename.endswith('.mp3'): print(f"{filename} 是一个音乐") else: print(f"{filename} 是一个其他文件") #运行结果 hello.png 是一个图片
1.3.3 字符串的数据清洗
""" 数据清洗的思路： strip:删除开头结尾的空格，广义的空格如真实的空格‘ ’,\n \t 等也都删除 lstrip:删除左侧的空格，广义的空格如真实的空格‘ ’,\n \t 等也都删除 rstrip:删除右侧的空格，广义的空格如真实的空格‘ ’,\n \t 等也都删除 replace:替换 """ s = ' hello westos ' print(s.strip()) ##删除开头结尾的空格，广义的空格如真实的空格‘ ’,\n \t 等也都删除 print(s.lstrip()) ##左侧 print(s.rstrip()) ##右侧 print(s.replace(' ','*')) ##将空格替换成*
1.4 字符串的位置调整
print("学生管理系统".center(50)) print("学生管理系统".center(50,'*')) print("学生管理系统".ljust(50,'*')) print("学生管理系统".rjust(50,'-')) #输出结果 学生管理系统 **********************学生管理系统********************** 学生管理系统******************************************** --------------------------------------------学生管理系统
1.5 字符串的搜索,统计
s = 'hello world' #find如果找到子串，则返回子串的索引位置，否则返回-1 #index如果找到子串，则返回子串的索引位置，否则报错(抛出异常) print(s.find('llo')) # 2 print(s.find('xxx')) # -1 print(s.index('llo'))# 2 print(s.count('l')) # 3 print(s.count('xx')) # 0 print(s.find('l',1,3))# 2
1.6 字符串的分离与拼接
ip = '172.25.70.1' items = ip.split('.') ##分离 print(items) items1= '-'.join(items) ##拼接 print(items1)
1.7 string模块
需求：随机生成100个验证码 import random,string for i in range(100): print(''.join(random.sample(string.digits,2)) + ''.join(random.sample(string.ascii_letters,4)))
1.8 其他内置方法
s = 'hello world' print(len(s)) ##返回字符串的字符数 print(max(s)) ##返回最大或者最小的字符,(按照 ASCII 码值排列) print(min(s)) print(enumerate(s))##枚举对象同时列出数据和数据下标 print(zip(s)) ##将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
1.9 小学生计算能力测试系统
设计一个程序，用来实现帮助小学生进行算术运算练习，它具有以下功能：提供基本算术运算(加减乘)的题目，每道题中的操作数是随机产生的，练习者根据显示的题目输入自己的答案，程序自动判断输入的答案是否正确并显示出相应的信息。最后显示正确率。
- 思路: 运行程序， 输入测试数字的大小范围 输入测试题目数量 任意键进入测试 系统进行测试并判断对错 系统根据得分情况进行总结，退出程序import random count = int(input("please input test count:")) right_count = 0 for i in range(count): num1 = random.randint(1,10) num2 = random.randint(1,10) symbol = random.choice(["+","-","*","/"]) result = eval(f"{num1}{symbol}{num2}") question= print(f"{num1}{symbol}{num2}=") user_answer = int(input(f"答案为:")) if user_answer == result: right_count += 1 print("回答正确") else: print("回答错误") print("right pencent: %.2f%%"%(right_count/count*100)) ##%%为%本身
1.10 IPV4合法性判断
编写一个函数来验证输入的字符串是否是有效的 IPv4 ?
1). IPv4 地址由十进制数和点来表示，每个地址包含4个十进制数，其范围为 0 - 255， 用(".")分割。
比如，172.16.253.1；
2). IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。ip = input('Please input ipv4:') ipv4 = ip.split('.') if len(ipv4) != 4 : print(f'{ipv4} 不是合法ip地址') #elif '.' not in ipv4: # print(f'{ipv4} 不是合法ip地址') else: for i in range(len(ipv4)): if int(ipv4[i])>255 and int(ipv4[i])<0: print(f"{ipv4} 不是合法的ip地址") else: pass print(f"{ipv4} 是合法的ip地址")1.11 机器人平面题
orientation = input("上(U),下(D),左(L),右(R) :") U=D=L=R=1 for i in orientation: if i=="U": U+=1 elif i=="D": D+=1 elif i=="L": L+=1 elif i=="R": R+=1 else: print('请输入正确的方向!!') print("True" if U==D and L==R else "False")
2. 序列
- 成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。 序列数据类型包括:字符串,列表,和元组类型。 特点: 都支持下面的特性 索引与切片操作符 成员关系操作符(in , not in) 连接操作符(+) & 重复操作符(*)
2. 数组、列表、元组
- 数组array：存储相同数据类型的数据结构。[1,2,3] [1.1,2.2] - 列表list：打了激素的数组，可以存储不同数据类型的数据结构。[1,1.1,'hello'] - 元组tuple：带了颈箍咒的列表，和列表唯一区别就是不能增删改2.1 列表
2.1.1 列表的创建
# 2.列表list list1 = [1,2,1.2,'hello'] print(list1)2.1.2 列表的基本特性
#1.连接操作符和重复操作符 print([1,2]+[2,3]) #[1, 2, 2, 3] print([1,2]*3) ##[1, 2, 1, 2, 1, 2] #2.成员操作符(in,not in ) print(1 in [1,2]) # True """ 布尔类型 True:1 False:0 """ print(1 in ['a',True,[1,2]]) #True 因为结果True相当于1 print(1 in ['a',False,[1,2]]) #False 因为False相当于0 #3.索引 li = [1,2,3,[1,'b',3]] print(li[0]) #1 print(li[-1]) #[1,'b',3] print(li[-1][1]) #1 print(li[3][-1]) #3 #4.切片 li = ['172','25','254','100'] print(li[:2]) print(li[1:]) print(li[::-1]) print('-'.join(li[3:0:-1])) print('-'.join(li[1:][::-1])) ##俩个切片，先顺序在逆序 #5.for循环 names = ['1','2','3'] for name in names: print(f"name{name}")2.1.3 列表的常用方法(增删改查)
#1.增加 li = [1,2,3] #1-1)追加 li.append(4) print(li) #[1, 2, 3, 4] #1-2)列表指定位置添加 li.insert(0,'cat') print(li) #['cat', 1, 2, 3, 4] li.insert(1,'cat') print(li) #['cat', 'cat', 1, 2, 3, 4] #1-3）一次追加多个元素 li = [1,2,3] li.extend([4,5,6]) print(li) #[1, 2, 3, 4, 5, 6] #2 修改 li = [1,2,3] li[0] = 'cat' print(li) #['cat', 2, 3] li[2] = 'westos' print(li) #['cat', 2, 'westos'] li[:2] = [1,1] print(li) # [1, 1, 'westos'] #3 查看 通过索引和切片查看元素，查看索引值和出现次数 li = [1,2,3,1,1,3] print(li.count(1)) # 3 print(li.index(3)) # 2 # 4.删除 # 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) #[] #5.其他操作 li = [1,2,3,4] li.reverse() ##反转 print(li) ##[4,3,2,1] li.sort() ##sort排序默认由小到大，如果想由大到小排序，设置reverse=True print(li) #[1, 2, 3, 4] li.sort(reverse=True) print(li) #[4, 3, 2, 1] li1= li.copy() ##复制，id不同 print(id(li1),id(li)) #31081896 31083056 print(li,li1) #[4, 3, 2, 1] [4, 3, 2, 1] del li ##直接删除li 列表2.2 元组
2.2.1 元组操作
# 元组简单示例 tuple1=(1,2.2,'das',[1,2,3]) print(tuple1) #1.元组的创建 t1 = () ##空元组 print(t1,type(t1)) #() <class 'tuple'> t2 = (1,) #重点：元组单个元素一定要加逗号 print(t2,type(t2)) #(1,) <class 'tuple'> t3 = (1,1.1,True) print(t3,type(t3)) #(1, 1.1, True) <class 'tuple'> #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 成员操作符in,not in print(1 in (1,2,3)) ## 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) # 3.常用方法：count和index，元组是不可变类型(不能增删改) t = (1,2,3,4,1,1) print(t.count(1)) #3 print(t.index(1)) #02.2.2 命名元组的操作
- Tuple还有一个兄弟，叫namedtuple。虽然都是tuple，但是功能更为强大。 - collections.namedtuple(typename, field_names) - typename：类名称 field_names: 元组中元素的名称tuple = ('westos',18,'西安') #普通元组 ##命名元组解决了读代码的烦恼 from collections import namedtuple ##命名元组的用法 #1.创建命名元组对象User User = namedtuple('User',('name','age','city')) # 2.给命名元组传值 user1 = User('westos',18,'xian') # 3.打印命名元组 print(user1) #User(name='westos', age=18, city='xian') print(user1.name) #westos print(user1.age) #18 print(user1.city) #xian2.3 地址引用和深拷贝和浅拷贝
""" 深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。 假设B复制了A，修改A的时候，看B是否发生变化： 如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值） 如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值） """ # 1. 值的引用 """ 赋值： 创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。(=) """ nums1 = [1,2,3,] nums2 = nums1 ##此时指向同一个内存空间 nums1.append(4) print(nums1) #[1, 2, 3, 4] print(nums2) #[1, 2, 3, 4] #2. 拷贝:浅拷贝和深拷贝 #2-1)浅拷贝 """ 浅拷贝： 对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。(li.copy(), copy.copy()) 公用一个值； 这两个变量的内存地址一样； 对其中一个变量的值改变，另外一个变量的值也会改变； 应用场景：核心: 如果列表的元素包含可变数据类型, 一定要使用深拷贝。 """ n1 = [1,2,3] n2 = n1.copy() ##n1.copy和ni[:]都可以实现拷贝 print(id(n1),id(n2)) ##copy指向不同的内存空间，所以互不影响 n1.append(4) print(n1) #[1, 2, 3, 4] ##相当于打印一份，然后在一份上做修改，不影响另一份 print(n2) #[1, 2, 3] #2-2)深拷贝 """ 如果列表的元素包含可变数据类型，一定要使用深拷贝 可变数据类型(可增删改的): list 不可变数据类型(变量指向的内存空间的值不会改变): str,tuple,nametuple """ n1 = [1,2,[1,2]] n2 = n1.copy() ##查看n1和n2的内存地址，发现进行了拷贝 print(id(n1),id(n2)) #16971096 16665136 #n1[-1]和n2[-1]的内存地址 print(id(n1[-1]),id(n2[-1])) #17020328 17020328 n1[-1].append(4) print(n1) #[1, 2, [1, 2, 4]]修改成功 print(n2) #[1, 2, [1, 2, 4]]也随之发生改变 #2-3)如何实现深拷贝copy.deepcopy """ 深拷贝： 一个变量对另外一个变量的值拷贝。(copy.deepcopy()) 两个变量的内存地址不同； 两个变量各有自己的值，且互不影响； 对其任意一个变量的值的改变不会影响另外一个； """ import copy n1 = [1,2,[1,2]] n2 = copy.deepcopy(n1) ##查看n1和n2的内存地址，发现进行了拷贝 print(id(n1),id(n2)) #16971096 16665136 #n1[-1]和n2[-1]的内存地址 print(id(n1[-1]),id(n2[-1])) #26564608 26565248 n1[-1].append(4) print(n1) #[1, 2, [1, 2, 4]]修改成功 print(n2) #[1, 2, [1, 2]]2.4 云主机操作练习
menu = """ 云主机管理系统 1). 添加云主机 2). 搜索云主机(IP搜索) 3). 删除云主机 4). 云主机列表 5). 退出系统 请输入你的选择:""" #思考1.所有的云主机信息如何存储？选择何种类型的数据类型存储？list #思考2.每一个云主机(IP,hostname,IDC)应该如何存储？命名元组 from collections import namedtuple hosts = [] Host = namedtuple('Host',('ip','hostname','IDC')) while True: choice = input(menu) if choice =='1' : print("添加云主机".center(50,'*')) ip = input("ip:") hostname = input("hostname:") IDC = input("IDC:") host1 = Host(ip,hostname,IDC) hosts.append(host1) print(f'添加{IDC}的云主机成功，ip地址为{ip}') elif choice =='2' : print("搜索云主机(IP搜索)".center(50, '*')) #作业：for循环(for ...else),判断，break for host in hosts: ipv4 = input("please input ipv4:") if ipv4 == host.ip: print(f'{ipv4} 对应的主机为{host.hostname}') else: break elif choice == '3': print("删除云主机".center(50, '*')) #作业:(选做) for host in hosts: delete_hostname = input("please input delete hostname:") if delete_hostname == host.hostname: hosts.remove(host) print(f'对应的主机为{host.hostname}') else: break elif choice == '4': print("云主机列表".center(50, '*')) print("IP\t\thostname\tIDC") count = 0 for host in hosts: count +=1 print(f'{host.ip}\t{host.hostname}\t{host.IDC}') print('云主机总个数为', count) elif choice == '5': exit() print("退出系统".center(50, '*')) else: print("请输入正确的选项")
3. 集合与字典
- 集合set：不重复且无序的(交集和并集) - 字典dict：{"name":"westos","age":10}，键值对3.1 集合
3.1.1 集合的操作
- 集合（set）是一个无序的不重复元素序列。1,2,3,4,1,2,3 = 1,2,3,4 集合的创建: 1). 使用大括号 { } 或者 set() 函数创建集合; 2). 注意： 创建一个空集合必须用 set() 而不是 { } { } 是用来创建一个空字典。
# 序言.set集合简单操作 set1={1,2,4,5} set2={2,3,4} print("交集：",set1 & set2) print("并集：",set1 | set2) ##输出结果 交集： {2, 4} 并集： {1, 2, 3, 4, 5} # 1.集合的创建 s = {1,2,3,1,2,3} print(s,type(s)) #{1, 2, 3} <class 'set'> #1-1)注意点1 #集合的元素必须是不可变数据类型 # s= {1,2,[1,2]} # print(s,type(s)) #TypeError: unhashable type: 'list' #1-2)注意点2，空集合不能使用{},而要使用set() s = set() print(s,type(s)) #set() <class 'set'> #2. 集合的特性:不重复无序的 #不支持+ , * ,in ,index , slice(切片) #支持in 和 not in 成员操作符 s = {1,2,3,4} print(1 in s) #True #3. 集合的常用方法 #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, '4', '6', '5'} s.update({4,5,6}) print(s) #{1, 2, 3, 100, '4', 4, 5, 6, '6', '5'} #3-2)删除 # remove如果元素存在删除，否则报错 # discard如果元素存在删除，否则不做任何操作 # pop随机删除一个元素，集合为空报错 s= {1,2,3} s.remove(3) #{1, 2} print(s) s.discard(100) #{1, 2} print(s) s= {1,2,3} s.pop() ##随机删除一个，很少用 print(s) #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} #子集 print(s1.issubset(s2)) #False #子集 print(s1.isdisjoint(s2)) #False #俩者没有交集么？ print(s1.issuperset(s2)) #父集 #4.排序 s={1,2,5,56,78,78,9} sorted(s) print(s) #5.拓展：frozenset不可变集合 s = frozenset({1,2,3}) print(s,type(s)) #frozenset({1, 2, 3}) <class 'frozenset'>3.1.2 集合的练习
import random N = int(input("please input people N:")) s=set() for i in range(N): num = random.randint(1,1000) s.add(num) s = sorted(s,reverse=True) ##必须重新赋值给s，不然排序不生效 print(s)3.2 字典
3.2.1 字典的操作
- 字典是另一种可变容器模型，且可存储任意类型对象。 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。#1.字典的创建dict #key-value对或键值对 dict1={"name":"westos","age":10,"city":"xian"} print(dict1,type(dict1)) #{'name': 'westos', 'age': 10, 'city': 'xian'} <class 'dict'> print(dict1["name"]) #westos #2.字典的特性:无序不重复 #不支持+ , * ,in ,index , slice(切片) #支持in 和 not in 成员操作符(主要是判断key值) dict1={"name":"westos","age":10,"city":"xian"} print("name" in dict1) #True print("westos" in dict1) #False #3.字典的常用方法 #3-1)查看 """ 查看所有: keys,values,items 查看局部: d[keys],d.get() """ dict1={"name":"westos","age":10,"city":"xian"} print(dict1.keys()) ##查看字典所有的key值,结果:dict_keys(['name', 'age', 'city']) print(dict1.values()) ##查看字典所有的values值,结果:dict_keys(['name', 'age', 'city']) print(dict1.items()) ##查看字典的item元素,结果:dict_items([('name', 'westos'), ('age', 10), ('city', 'xian')]) print(dict1['name']) ##查看key name对应的values值,结果:westos #print(dict1['province']) ##查看key不存在的会报错 print(dict1.get('province')) ##获取查看key对应的value值，如果存在则返回，不存在返回None。 print(dict1.get('province','shanxi')) ##获取查看key对应的value值，如果存在则返回，不存在返回默认值shanxi 。 dict1={"name":"westos","age":10,"city":"xian","province":"山东"} print(dict1.get('province','shanxi')) ##山东 #3-2)增加和修改 #update添加多个元素 dict1={"name":"westos","age":10} dict1["city"] = "西安" ##key 不存在则添加 print(dict1) #{'name': 'westos', 'age': 10, 'city': '西安'} dict1["city"] = "北京" ##key 存在则修改 print(dict1) #{'name': 'westos', 'age': 10, 'city': '北京'} dict1={"name":"westos","age":10} dict1.setdefault("city",'西安') ##key 不存在则添加 print(dict1) #{'name': 'westos', 'age': 10, 'city': '西安'} dict1.setdefault("city",'北京') ######key 存在则不做任何操作 print(dict1) #{'name': 'westos', 'age': 10, 'city': '西安'} #3-4)删除pop和del常用,popitem随机删除不常用 dict1={"name":"westos","age":10} dict1.pop('name') print(dict1) #{'age': 10} dict1={"name":"westos","age":10} del dict1['name'] print(dict1) #{'age': 10} #4. 遍历字典 dict1={"name":"westos","age":10,"city":"xian"} #默认情况下，只会遍历key for item in dict1: print(item) #如何遍历字典的key和value呢?特别重要 for item in dict1.items(): print(item) for key,value in dict1.items(): print(f"key={key}, value={value}")3.2.2 默认字典
- collections.defaultdict类，本身提供了默认值的功能， 默认值可以是整形，列表，集合等. defaultdict 是 dict 的子类。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 访问 value，会引发 KeyError 异常；而 defaultdict 提供default_factory 属性，该为不存在的 key 来 自动生成生成默认的 value - 解决方案： 1). 字典是一种关联容器，每个键都映射到一个单独的值上。如果想让键映射到多个值，需要将这些多个值保存到容器（列表或者集合）中。 2). 利用collections模块中的defaultdict类自动初始化第一个值，这样只需关注添加元素.from collections import defaultdict # 默认字典 设置默认value值 d = defaultdict(int) d["vier"] +=1 d["sss"] +=1 print(d) #defaultdict(<class 'int'>, {'vier': 1, 'sss': 1}) d = defaultdict(list) d["allow_user"].append("westos") d["deny_user"].append("linux") print(d) #defaultdict(<class 'list'>, {'allow_user': ['westos'], 'deny_user': ['linux']}) d= defaultdict(set) d["movies"].add("黑客帝国") d["movies"].update({"A计划"}) print(d) #defaultdict(<class 'set'>, {'movies': {'黑客帝国', 'A计划'}})3.2.3 练习题
""" 技能需求: 1.文件操作 2.字符串的分割操作 3.字典操作 功能需求:词频统计 1.读取文件song.txt with open(song.txt) as f : content = f.read() 2.加载分析文件中的每一个单词,统计每个单词出现的次数,使用split分割 #先设定空字典{}，统计次数一个一个往进加 song.txt文件内容 hello python hello java hello golong hello sql hello php hello perl hello ruby hello k8s k8s is good k8s is best """ #方法一: word = {} with open('doc/song.txt') as f: content = f.read() song = content.split(' ' or '\n') print(song) for item in song: if item not in word: word[item]=1 else: word[item]+=1 print(word) #方法二 with open('doc/song.txt') as f: content = f.read().split() #2.统计 result ={} for word in content: if word in result: result[word] +=1 else: result[word] =1 ##自动换行小技巧，友好打印信息 import pprint pprint.pprint(result) #方法三(小技巧) #1. 加载文件中所有单词 with open('doc/song.txt') as f: content = f.read().split() #2.统计 from collections import Counter counter = Counter(content) ##统计个数Counter({'hello': 8, 'k8s': 3, 'is': 2, 'python': 1, 'java': 1, 'golong': 1, 'sql': 1, 'php': 1, 'perl': 1, 'ruby': 1, 'good': 1, 'best': 1}) print(counter) result = counter.most_common(5) ##统计出现次数最多的5个单词[('hello', 8), ('k8s', 3), ('is', 2), ('python', 1), ('java', 1)] print(result)
4.内置数据结构总结
可变数据类型:可以增删改。可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。
不可变数据类型:不可以增删改。python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象。
""" 1.可变和不可变 - 可变数据类型：list,set,dict - 不可变数据类型:数值类型,tuple,str 2.序列:能否进行for循环 - 有序:索引、切片、连接操作符、重复操作符以及成员操作符等特性 - 无序 - 非序列 """
5.力扣算法题
5.1 俩数之和
#法一:自己想的 import random count = int(input("please input num count:")) target= int(input("please input target:")) nums = [] for i in range(count): num = random.randint(0,10) nums.append(num) print(nums) for j in range(len(nums)): for z in range(j+1,len(nums)): if nums[j]+nums[z]==target: print(f"{j}和{z}") #法二:官网 nums = [2,7,11,15] n = len(nums) target= int(input("please input target:")) for i in range(n): for j in range(i + 1, n): if nums[i] + nums[j] == target: print(f"{i}和{j}") #法三：时间复杂度为O(1),采用hash/字典办法 nums = [2,7,11,15] n = len(nums) target= int(input("please input target:")) hashes = {} for i in range(n): if target - nums[i] in hashes: print(hashes[target - nums[i]],i) hashes[nums[i]] = i5.2 无重复字符串
GitCode 天启AI是一款由 GitCode 团队打造的智能助手，基于先进的LLM（大语言模型）与多智能体 Agent 技术构建，致力于为用户提供高效、智能、多模态的创作与开发支持。它不仅支持自然语言对话，还具备处理文件、生成 PPT、撰写分析报告、开发 Web 应用等多项能力，真正做到“一句话，让 Al帮你完成复杂任务”。
更多推荐
1
0- 0
已为社区贡献2条内容
所有评论(0)