一.变量的赋值操作
x=1 a=10 b=10 # #链式赋值 a=b=c=d=e=f=10 print(a,b,c,d,e,f) #多元赋值 #方式一 x=1 y=2 z=x #z=1 x=y #x=2 y=z #y=1 print(x,y) #方式二：python特有 x,y=y,x print(x,y) #增量赋值 x=10 x+=1 #x=x+1 print(x) #解压序列类型 s=‘hello‘ a=s[0] b=s[1] c=s[2] d=s[3] e=s[4] print(a,b,c,d,e) a,b,c,d,e=s print(a,b,c,d,e) a,_,_,_,e=‘alexs‘ print(a,e) print(_) a,*_,e=‘alexs‘ print(a,e) m,n,*_=‘alexs‘ print(m,n) *_,m,n=‘alexs‘ print(m,n)
二.列表
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
用途（存多个值，可以修改）：爱好，装备，女朋友们
hobby=[‘play‘,‘eat‘,‘sleep‘]
方法：
hobby.append
hobby.remove
操作：
查看：
>>> girls=[‘alex‘,‘wsb‘,[‘egon‘,‘ysb‘]]
>>> girls[2]
[‘egon‘, ‘ysb‘]
>>> girls[2][0]
增加
girls.append(元素)
删除
girls.remove(元素)
del girls[元素的索引]
修改
girls[0]=‘alexSB‘
#定义列表 # l=[1,‘a‘,[3,4]] #l=list([1,‘a‘,[3,4]]) #取值 # print(l[0]) # print(l[2][0]) # # l=[1,2,[[‘a‘,‘b‘],‘c‘]] # print(l[2][0][1]) #循环 l=[1,2,3,[4,5]] # count=0 # while count < len(l): # print(l[count]) # count+=1 # for count in range(len(l)): # print(l[count]) # l=[1,2,3,[4,5]] # for count in range(len(l)): # if type(l[count]) is list: # #pass # for i in range(len(l[count])): # print(l[count][i]) # else: # print(l[count]) # l=[1,2,3,[4,5]] # l_size=len(l) # for index in range(l_size): # value=l[index] # if type(value) is list: # #value是列表,value=[4,5] # for i in range(len(value)): # print(value[i]) # else: # #value不是列表，直接打印 # print(value) # # print(‘没有修改之前的列表：‘,id(l),type(l),l) # #id不动，type也不动，value被修改了，则称为可变类型 #可变指的是：在id和type不动的前提下，值可变 # print(l[0]) # print(l[2][1]) # l[0]=11111111111111111 # print(l) # print(‘修改之后的列表：‘,id(l),type(l),l) #列表常用操作 # 索引 # 切片 # l=[‘ab‘,1,2,‘hello‘] # print(l[1:3]) #切片操作是读操作，并不会修改原来的数据 # print(l) # 追加 # l=[‘ab‘,1,2,‘hello‘] # print(l) # l.append(‘alex‘) # l.append(‘alex1‘) # l.append(‘alex2‘) # l.append(‘alex3‘) # print(l) # 插入 # l.insert(0,‘first‘) # print(l) # l.insert(2,‘abc‘) # print(l) # 删除 # l=[‘a‘,‘b‘,‘c‘,‘hello‘] # print(l) # l.pop(1) # print(l) # l.pop() # l.pop() # l.pop(0) # l.pop(0) # print(‘刚刚删除的元素是‘,l.pop(0)) # # print(l) #队列：先进先出 l=[] #append与pop(0) #入队列 # l.append(‘people1‘) # l.append(‘people2‘) # l.append(‘people3‘) # print(l) #出队列 # print(l.pop(0)) # print(l.pop(0)) # print(l.pop(0)) #insert(0,item) #入队 l.insert(0,‘people1‘) l.insert(0,‘people2‘) l.insert(0,‘people3‘) # print(l) #出队 # print(l.pop()) # print(l) # print(l.pop()) # print(l) # print(l.pop()) #堆栈：先进后出,或者说后进的先出 #append与 # l=[] # l.append(‘people1‘) # l.append(‘people2‘) # l.append(‘people3‘) # print(l) # print(l.pop()) # print(l.pop()) # print(l.pop()) # 长度 l=[1,2,3] # print(len(l)) # 切片 # 循环 # 包含 # s=‘alex is sb‘ # print(‘sb‘ in s) # # names=[‘alex‘,‘egon‘,‘yuanhao‘] # print(‘yuanhao‘ in names) #列表的其他操作 l=list([‘a1‘,‘a2‘,‘a3‘]) # print(l) # print(l.index(‘a2‘)) # # l.append(‘a2‘) # print(l.count(‘a2‘)) # print(l) # l.extend([1,2,3]) # l.append([1,2,3]) # print(l) # print(l) # l.remove(‘a2‘) # l=[‘a1‘,‘a2‘,‘a1‘,‘a1‘,‘a3‘] # l.remove(‘a1‘) # print(l) # l=[2,3,1] # l.sort(reverse=True) # print(l) # l=[‘a‘,‘c‘,‘alex‘] # l.reverse() # print(l)
# l=[1,2,3] #l=list([1,2,3]) # print(type(l)) #pat1===》优先掌握部分 # 索引 # # 切片 l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘] # print(l[1:5]) # print(l[1:5:2]) # print(l[2:5]) # print(l[-1]) #了解 # print(l[-1:-4]) # print(l[-4:]) # l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘] # print(l[-2:]) # 追加 # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # hobbies.append(‘girls‘) # print(hobbies) # 删除 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # x=hobbies.pop(1) #不是单纯的删除，是删除并且把删除的元素返回，我们可以用一个变量名去接收该返回值 # print(x) # print(hobbies) # x=hobbies.pop(0) # print(x) # # x=hobbies.pop(0) # print(x) #队列：先进先出 queue_l=[] #入队 # queue_l.append(‘first‘) # queue_l.append(‘second‘) # queue_l.append(‘third‘) # print(queue_l) #出队 # print(queue_l.pop(0)) # print(queue_l.pop(0)) # print(queue_l.pop(0)) #堆栈:先进后出，后进先出 # l=[] # #入栈 # l.append(‘first‘) # l.append(‘second‘) # l.append(‘third‘) # #出栈 # print(l) # print(l.pop()) # print(l.pop()) # print(l.pop()) #了解 # del hobbies[1] #单纯的删除 # hobbies.remove(‘eat‘) #单纯的删除，并且是指定元素去删除 # 长度 # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # print(len(hobbies)) # 包含in # hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘] # print(‘sleep‘ in hobbies) # msg=‘hello world egon‘ # print(‘egon‘ in msg) ##pat2===》掌握部分 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # hobbies.insert(1,‘walk‘) # hobbies.insert(1,[‘walk1‘,‘walk2‘,‘walk3‘]) # print(hobbies) # print(hobbies.count(‘eat‘)) # print(hobbies) # hobbies.extend([‘walk1‘,‘walk2‘,‘walk3‘]) # print(hobbies) hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # print(hobbies.index(‘eat‘)) #pat3===》了解部分 hobbies=[‘play‘,‘eat‘,‘sleep‘,‘study‘,‘eat‘,‘eat‘] # hobbies.clear() # print(hobbies) # l=hobbies.copy() # print(l) # l=[1,2,3,4,5] # l.reverse() # print(l) l=[100,9,-2,11,32] l.sort(reverse=True) print(l)
三.元组
作用：存多个值，对比列表来说，元组不可变，主要是用来读
定义：与列表类型，只不过[]换成()
可以当做字典的key
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
常用操作：
索引
切片
循环
长度
包含in
#为何要有元组，存放多个值，元组不可变，更多的是用来做查询
t=(1,[1,3],‘sss‘,(1,2)) #t=tuple((1,[1,3],‘sss‘,(1,2)))
# print(type(t))
# #元组可以作为字典的key
# d={(1,2,3):‘egon‘}
# print(d,type(d),d[(1,2,3)])
# 索引
#
# 切片
# goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘)
# print(goods[1:3])
#
# 长度
#
#in:
#字符串:子字符串
#列表：元素
#元组：元素
#字典：key
# goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘)
# print(‘iphone‘ in goods)
# d={‘a‘:1,‘b‘:2,‘c‘:3}
# print(‘b‘ in d)
#掌握
# goods=(‘iphone‘,‘lenovo‘,‘sanxing‘,‘suoyi‘)
# print(goods.index(‘iphone‘))
# print(goods.count(‘iphone‘))
#补充：元组本身是不可变的，但是内部的元素可以是可变类型
t=(1,[‘a‘,‘b‘],‘sss‘,(1,2)) #t=tuple((1,[1,3],‘sss‘,(1,2)))
# t[1][0]=‘A‘
# print(t)
# t[1]=‘aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa‘
#元组的元素可以是任意数据类型
t=(‘a‘,1,‘b‘,1,(3,4))
# print(id(t),type(t),t)
#元组的特性是：不可变
#取值
# print(t[4][0])
#循环
t=(‘a‘,1,‘b‘,1,(3,4))
# index=0
# while index < len(t):
# print(t[index])
# index+=1
# for i in range(len(t)):
# print(t[i])
#tuple类型的方法
# print(t.count(1))
# print(t.index(‘b‘))
#tuple常用操作
# 索引
# 切片
# t=(‘a‘,1,‘b‘,1,(3,4))
# print(t[1:3])
# print(t)
# 循环
# 长度
# print(len(t))
# 包含
#
# print(‘a‘ in t)
#元组的特性是：不可变,元组的元素可以是任意数据类型
# t=(1,2,[‘a‘,‘b‘])
# print(id(t),type(t),t)
# t[2][0]=‘aaaaaaa‘
# print(t)
# print(id(t),type(t),t)
# t[2]=3
# t[2][0]=123123123123
#评论
# comments=[(‘真傻比‘,),(‘确实傻逼‘,)]
# print(comments)
# # comments.pop(0)
# comments[0]=‘真牛逼‘
# print(comments)
四.字典
用途：存多个值，这一点与列表相同，值可以是任意数据类型
特征：每一个值都一个唯一个对应关系，即key，强调一点，key必须是
不可变类型：字符串，数字
student_info={
‘age‘:81,
‘name‘:‘alex‘,
‘sex‘:None,
‘hobbies‘:[‘zsb0‘,‘zsb1‘,‘zsb2‘,‘zsb30‘]
}
操作：
查看
>>> student_info={
... ‘age‘:81,
... ‘name‘:‘alex‘,
... ‘sex‘:None,
... ‘hobbies‘:[‘zsb0‘,‘zsb1‘,‘zsb2‘,‘zsb30‘]
... }
>>>
>>> student_info[‘age‘]
81
>>> student_info[‘hobbies‘]
[‘zsb0‘, ‘zsb1‘, ‘zsb2‘, ‘zsb30‘]
>>> student_info[‘hobbies‘][2]
‘zsb2‘
增加
student_info[‘stu_id‘]=123456
删除
del student_info[‘stu_id‘]
修改
student_info[‘name‘]=‘alexSB‘
#字典的常用方法
d={‘x‘:1,}
# d.clear()
# print(d)
# print(d[‘x‘])
# print(d[‘y‘])
# print(d.get(‘y‘))
# print(d.get(‘y‘,‘找不到的啦‘))
# print(d.get(‘x‘,‘找不到的啦‘))
d={‘x‘:1,‘y‘:1}
# print(d.items())
# for item in d.items(): #[(‘x‘, 1), (‘y‘, 1)]
# print(item)
# for k,v in d.items(): #[(‘x‘, 1), (‘y‘, 1)]
# print(k,v)
# d={‘x‘:1,‘y‘:1}
# print(d.keys())
# for i in d.keys():
# print(i)
# for i in d:
# print(i)
d={‘x‘:1,‘y‘:1}
# print(d.keys(),type(d.keys()))
#
# res=list(d.keys())
# print(res,type(res))
d={‘x‘:1,‘y‘:12222}
# print(d.values())
# print(list(d.values()))
# print(list(d.values())[1])
# res=d.pop(‘y‘)
# print(res)
#
# print(d)
# d={‘x‘:1,‘y‘:12222}
# print(d.pop(‘z‘,‘没有的啦‘))
#
# d={‘x‘:1,‘y‘:12222}
# print(d.popitem())
# print(d)
# d={‘x‘:1,‘y‘:12222}
#
# # d.setdefault(‘z‘,3)
# # print(d)
#
# # d[‘name‘]=‘egon‘
# # print(d)
#
# d={‘x‘:1,‘y‘:12222}
# print(d.setdefault(‘x‘,3333333333333333333333333333))
# print(d)
# d1={}
# d2=dict()
# print(d1,d2)
#
# d3=dict(x=1,y=2,z=3)
# print(d3)
#
#
# d4=dict({‘x‘:1,‘y‘:2,‘z‘:3})
# print(d4)
#
#
#
# d5=dict([(‘x‘,1),(‘y‘,2),(‘z‘,3)])
# print(d5)
#
#
# d6={}.fromkeys([‘name‘,‘age‘],None)
# print(d6)
#
# d7={}.fromkeys([‘name‘,‘age‘],[‘egon‘,18])
# print(d7)
#
# d={‘name‘:‘alex‘,‘sex‘:‘male‘}
#
# d1={‘name‘:‘alexsb‘,‘age‘:50}
# d.update(d1)
# print(d)
#新增
d={}
d[‘x‘]=1
print(d)
# 删除
# d.pop(‘x‘)
# d.popitem()
# 键、值、键值对
# d.keys()
# d.values()
# d.items()
# 循环
# 长度
#
# d={‘x‘:1,‘u‘:2}
# print(len(d))
# #成员运算
# d={‘x‘:1,‘u‘:2}
#
# print(‘x‘ in d)
# print(1 in d.values())
#字典定义的基本形式：key:value
# d={‘name‘:‘egon‘,‘age‘:18} #d=dict({‘name‘:‘egon‘,‘age‘:18})
#
# print(id(d),type(d),d)
#定义字典需要注意的问题：key必须是不可变类型，或者说是可hash类型
# print(hash(1))
# print(hash(‘xxxxxx‘))
# print(hash((1,2,3)))
# print(hash({‘a‘:1}))
d={1:‘id‘,‘a‘:1,‘b‘:2,‘name‘:‘egon‘,(1,2):‘aaaaaaaa‘}
#字典的取值,字典是无序的
# print(d[1])
# print(d[‘name‘])
# print(d[(1,2)])
# d={‘name‘:‘alex‘,‘age‘:18}
# print(d[‘name‘])
# d[‘name‘]=‘aaaaasb‘
# print(d)
#循环
d={‘name‘:‘alex‘,‘age‘:18,‘sex‘:‘male‘,‘height‘:130,‘weight‘:200}
# print(d.keys())
# print(d.values())
# print(type(d.keys()))
# for k in d:
# print(k,d[k])
# l=[1,2,3]
# for i in l:
# print(i)
# t=(1,2,3)
# for i in t:
# print(i)
# s=‘hello‘
# for i in s:
# print(i)
‘‘‘
一：可变不可变
可变：列表，字典
不可变：数字，字符串，元组
二：存放值的个数
一个值：数字，字符串
多个值(容器类型)：列表，元组，字典
三：取值方式
直接取值：数字
序列类型：字符串，元组，列表
映射类型：字典
‘‘‘
#字典的嵌套使用
# d={‘a‘:1}
# print(d[‘b‘])
# print(d.get(‘a‘))
# user_info=[
# {‘username‘:‘egon‘,‘password‘:‘123‘},
# {‘username‘:‘alex‘,‘password‘:‘alex3714‘},
# {‘username‘:‘yuanhao‘,‘password‘:‘sb123‘},
# ]
# for item in user_info:
# print(item[‘username‘],item[‘password‘])
# tag=True
# while tag:
# user=input(‘u>>: ‘)
# pwd=input(‘p>>: ‘)
# for item in user_info:
# if user == item[‘username‘] and pwd ==item[‘password‘]:
# print(‘login ok‘)
# tag=False
# break
# user_info=[
# {‘username‘:‘egon‘,‘password‘:‘123‘},
# {‘username‘:‘alex‘,‘password‘:‘alex3714‘},
# {‘username‘:‘yuanhao‘,‘password‘:‘sb123‘},
# ]
user_dic={
‘egon‘:‘123‘,
‘alex‘:‘alex3714‘,
‘yuanhao‘:‘sb123‘
}
# print(‘egon‘ in user_dic)
while True:
user=input(‘u>>: ‘)
pwd=input(‘p>>: ‘)
if user in user_dic:
if pwd == user_dic[user]:
print(‘login ok‘)
break
# if user == ‘egon‘ and pwd == ‘123‘:
# print(‘login ok‘)
# break
练习
1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。（2分）
即： {‘k1‘: 大于66的所有值, ‘k2‘: 小于66的所有值}
a={‘k1‘:[],‘k2‘:[]}
c=[11,22,33,44,55,66,77,88,99,90]
for i in c:
if i>66:
a[‘k1‘].append(i)
else:
a[‘k2‘].append(i)
print(a)
2 统计s=‘hello alex alex say hello sb sb‘中每个单词的个数
结果如：{‘hello‘: 2, ‘alex‘: 2, ‘say‘: 1, ‘sb‘: 2}
s=‘hello alex alex say hello sb sb‘
l=s.split()
dic={}
for item in l:
if item in dic:
dic[item]+=1
else:
dic[item]=1
print(dic)
s=‘hello alex alex say hello sb sb‘
dic={}
words=s.split()
print(words)
for word in words: #word=‘alex‘
dic[word]=s.count(word)
print(dic)
#利用setdefault解决重复赋值
‘‘‘
setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值
d={}
print(d.setdefault(‘a‘,1)) #返回1
d={‘a‘:2222}
print(d.setdefault(‘a‘,1)) #返回2222
‘‘‘
s=‘hello alex alex say hello sb sb‘
dic={}
words=s.split()
for word in words: #word=‘alex‘
dic.setdefault(word,s.count(word))
print(dic)
#利用集合，去掉重复，减少循环次数
s=‘hello alex alex say hello sb sb‘
dic={}
words=s.split()
words_set=set(words)
for word in words_set:
dic[word]=s.count(word)
print(dic)
其他做法（重点看setdefault的用法）
五.集合
作用：去重，关系运算，
知识点回顾
可变类型是不可hash类型 不可变类型是可hash类型
定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
常用方法：
in 和 not in
|合集
&交集
-差集
^对称差集
==
>，>= ，<,<= 父集，子集
练习：
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}
linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={‘alex‘,‘egon‘,‘yuanhao‘,‘wupeiqi‘,‘gangdan‘,‘biubiu‘}
linuxs={‘wupeiqi‘,‘oldboy‘,‘gangdan‘}
# 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 求出所有报名的学生名字集合
print(pythons | linuxs)
# 求出只报名python课程的学员名字
print(pythons - linuxs)
# 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
二.去重
1. 有列表l=[‘a‘,‘b‘,1,‘a‘,‘a‘]，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
2.在上题的基础上，保存列表原来的顺序
3.去除文件中重复的行，肯定要保持文件内容的顺序不变
4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[ {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}, {‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘}, {‘name‘:‘egon‘,‘age‘:20,‘sex‘:‘female‘}, {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}, {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},]
#去重,无需保持原来的顺序
l=[‘a‘,‘b‘,1,‘a‘,‘a‘]
print(set(l))
#去重,并保持原来的顺序
#方法一:不用集合
l=[1,‘a‘,‘b‘,1,‘a‘]
l1=[]
for i in l:
if i not in l1:
l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
if i not in s:
s.add(i)
l1.append(i)
print(l1)
#同上方法二,去除文件中重复的行
import os
with open(‘db.txt‘,‘r‘,encoding=‘utf-8‘) as read_f, open(‘.db.txt.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
s=set()
for line in read_f:
if line not in s:
s.add(line)
write_f.write(line)
os.remove(‘db.txt‘)
os.rename(‘.db.txt.swap‘,‘db.txt‘)
#列表中元素为可变类型时,去重,并且保持原来顺序
l=[
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:20,‘sex‘:‘female‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
]
# print(set(l)) #报错:unhashable type: ‘dict‘
s=set()
l1=[]
for item in l:
val=(item[‘name‘],item[‘age‘],item[‘sex‘])
if val not in s:
s.add(val)
l1.append(item)
print(l1)
#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
s=set()
for item in items:
val=item if key is None else key(item)
if val not in s:
s.add(val)
yield item
print(list(func(l,key=lambda dic:(dic[‘name‘],dic[‘age‘],dic[‘sex‘]))))
时间： 2024-10-25 12:57:41