python全栈开拓,数据类型总计

1、首先依照以下多少个点开始展览对聚集的就学

python全栈开辟-Day五 集结,python-day伍集结

一.变量的赋值操作

澳门葡京备用网址 1澳门葡京备用网址 2

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)

View Code

 

 

 一 元组

意义:存八个值,比较列表来讲,元祖不可变(可以看成自定的key值),首要用来读

概念: 与列表类型比,只可是[
] 换成了()

澳门葡京备用网址 3

一、按索引取值(正向取+反向取):只好取
              # 和列表同样

二、切成条(顾前不顾后,步长)
                                  # 和列表同样

3、长度                        
                                              # 和列表同样

四、成员运算 in 和not in        
                                     # 和列表一样

5、循环                        
                                              # 和列表同样

注:上边是必须理解的,上边是亟需掌握的

6、index                      
                                               # 和列表同样

7、count                      
                                              # 和列表同样

八、元祖类型计算:

能够存多少个值,只好够是不管37二拾一等级次序,有序,值不可变,可hash

#壹:基本使用

python全栈开垦-Day5 会集

二.列表

定义:[]内以逗号分隔,依照索引,存放种种数据类型,每一种岗位代表贰个因素
特性:
1.可存放多少个值
二.可修改钦点索引地方对应的值,可变
三.比照从左到右的各样定义列表成分,下标从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’

列表的拼凑:

澳门葡京备用网址 4澳门葡京备用网址 5

#1.用list的extend方法,L1.extend(L2),该方法将参数L2的全部元素添加到L1的尾部,例如:

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1.extend(L2)
print(L1)  #[1, 2, 3, 4, 5, 20, 30, 40]

#2.用切片(slice)操作,L1[len(L1):len(L1)] = L2和上面的方法等价,例如:

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[len(L1):len(L1)] = L2
print(L1)   #[1, 2, 3, 4, 5, 20, 30, 40]

#但切片方法用起来更灵活,可以插入到头部,或其他任意部位,例如:
加到开头:

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[0:0] = L2
print(L1)   #[20, 30, 40, 1, 2, 3, 4, 5]

#3加到中间:

L1 = [1, 2, 3, 4, 5]
L2 = [20, 30, 40]
L1[1:1] = L2
print(L1)   #[1, 20, 30, 40, 2, 3, 4, 5]

列表的拼凑

 

澳门葡京备用网址 6澳门葡京备用网址 7

#定义列表
# 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)

View Code

澳门葡京备用网址 8澳门葡京备用网址 9

# 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)

View Code

 

二 字典

用途:存放四个值,key:value,存取速度快

定义:

key必须是不足变类型(int,float,str,tuple),value能够是随意等级次序

澳门葡京备用网址 10

一、快捷产生字典的形式:

澳门葡京备用网址 11

二、安key存取值,可存可取

澳门葡京备用网址 12 

3、长度
len

print(len(ls))

四、成员运算  
in 和 not in   (用key来剖断)

5、循环

澳门葡京备用网址 13

6、删除

澳门葡京备用网址 14

 补充:

澳门葡京备用网址 15

 7、取建keys,
 值 values(),建值对items() (了解)

 澳门葡京备用网址 16

8、小练习

澳门葡京备用网址 17

注:
以上为必会手艺,以下为操纵手艺

9、 取值key
的2中方法

澳门葡京备用网址 18

10、update

澳门葡京备用网址 19

11、setdefault

澳门葡京备用网址 20

 

小练习:

澳门葡京备用网址 21

python全栈开拓,数据类型总计。练习二:

计算s=’hello alex alex say hello sb
sb’中各种单词的个数

方法一:

澳门葡京备用网址 22

方法二:

澳门葡京备用网址 23

方法三:

澳门葡京备用网址 24

1二、字典总括

可变类型,不可hash

  1 、用途

1、首先遵照以下多少个点进行对聚集的上学

三.元组

意义:存多少个值,相比列表来讲,元组不可变,首若是用来读

  定义:与列表类型,只不过[]换成()

    能够当做字典的key

    age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

  常用操作:

    索引

    切片

    循环

    长度

    包含in

澳门葡京备用网址 25澳门葡京备用网址 26

#为何要有元组,存放多个值,元组不可变,更多的是用来做查询
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)

View Code

 

三、集合

 成效:做涉嫌运算,去重

概念:{}内用逗号分隔,每种成分必须是不行变类型,成分不能够重新,严节

澳门葡京备用网址 27

 

1、长度:

print(len(s))

2、成员运算 in
    not  in

3、 交集
 &

澳门葡京备用网址 28

4、合集  
|

澳门葡京备用网址 29

五、对称差集  ^  
(交集之外的装有因素的重组)

澳门葡京备用网址 30

6、差集   –
  

 澳门葡京备用网址 31

7、父集 >=  
>   子集 <=   < 

澳门葡京备用网址 32

8、相关内部命令

澳门葡京备用网址 33

澳门葡京备用网址 34

小练习:

澳门葡京备用网址 35

 

  2 、定义情势

#一:基本选取

四.字典

用途:存五个值,那一点与列表一样,值能够是即兴数据类型
特点:各种值都多少个唯一个对应关系,即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’

澳门葡京备用网址 36澳门葡京备用网址 37

#字典的常用方法
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())

View Code

澳门葡京备用网址 38澳门葡京备用网址 39

#字典定义的基本形式: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

View Code

 练习

  一 就像是下值会集 [11,22,33,44,55,66,77,88,99,90…],将具有大于 6六的值保存至字典的率先个key中,将低于 6陆的值保存至第三个key的值中。(二分)

  即: {‘k一’: 大于6陆的具有值, ‘k二’: 小于6陆的全部值}

澳门葡京备用网址 40澳门葡京备用网址 41

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)

View Code

二 总计s=’hello alex alex say hello sb sb’中每种单词的个数

  结果如:{‘hello’: 2, ‘alex’: 2, ‘say’: 1, ‘sb’: 2}

澳门葡京备用网址 42澳门葡京备用网址 43

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)

View Code

澳门葡京备用网址 44澳门葡京备用网址 45

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的用法)

 

 

  3 、常用操作+内置的章程

  1 、用途

五.集合

功能:去重,关系运算,

知识点回看

可变类型是不可hash类型 不可变类型是可hash类型

 

概念集合:

会晤:能够包括四个因素,用逗号分割,

集中的成分遵从多少个规范:

1:各种成分必须是不足变类型(可hash,可作为字典的key)

二:未有重新的因素

叁:冬季注意会集的目标是将区别的值存放到一齐,不相同的集结间用来做涉嫌运算,无需纠结于聚聚焦单个值

 

常用方法:

    in 和 not in

    |合集

    &交集

    -差集

澳门葡京备用网址 ,    ^对称差集

    ==

    >,>= ,<,<= 父集,子集

 

  练习:

  一.关系运算
  有如下三个聚众,pythons是报名python课程的上学的小孩子名字群集,linuxs是报名linux课程的学生名字集结
  pythons={‘alex’,’egon’,’yuanhao’,’wupeiqi’,’gangdan’,’biubiu’}
  linuxs={‘wupeiqi’,’oldboy’,’gangdan’}
  一. 求出即报名python又报名linux课程的学生名字集结
  二. 求出全数报名的学生名字集合
  三. 求出只报名python课程的学童名字
  肆. 求出未有同时那两门学科的学员名字会集

澳门葡京备用网址 46澳门葡京备用网址 47

# 有如下两个集合,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)

View Code

二.去重

   1.
有列表l=[‘a’,’b’,1,’a’,’a’],列表成分均为可hash类型,去重,得到新列表,且新列表不需求维持列表原来的各种

*  * 二.在上题的根基上,保存列表原来的次第

   三.去除文件中再度的行,鲜明要保持文件内容的逐壹不改变
  
四.有如下列表,列表成分为不可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'},
]

澳门葡京备用网址 48澳门葡京备用网址 49

#去重,无需保持原来的顺序
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']))))

View Code

 

#二:该项目计算

  二 、定义形式

  一、 存二个值or存几个值 只好存三个值 能够存多少个值,值都能够是哪些项目

  叁 、常用操作+内置的主意

  2 、有序or无序

#二:该品种计算

  3 、可变or不可变 !!!可变:值变,id不变。可变==不可hash !!!不可变:值变,id就变。不可变==可hash

  1、 存1个值or存八个值 只好存1个值 能够存多个值,值都能够是如何类型

二、集合

  2 、有序or无序

#效果:去重,关系运算,

  3 、可变or不可变 !!!可变:值变,id不变。可变==不可hash !!!不可变:值变,id就变。不可变==可hash

# 知识点回顾 可变类型是不可hash类型 不可变类型是可hash类型

二、集合

#概念集结:

#功效:去重,关系运算,

   集结:可以涵盖八个元素,用逗号分割,

# 知识点回想 可变类型是不可hash类型 不可变类型是可hash类型

   集合的要素坚守多少个条件:

#概念集结:

  1:每一个成分必须是不可变类型(可hash,可看做字典的key)

   集结:能够蕴含多少个因素,用逗号分割,

  二:   未有重新的因素

   集合的成分遵从四个典型:

  3:无序

  壹:每一个成分必须是不足变类型(可hash,可看作字典的key)

  注意集结的目标是将分歧的值存放到壹块,分歧的集聚间用来做涉嫌运算,没有须要纠结于聚集中单个值

  贰:   未有再度的成分

#先期通晓的操作:

  3:无序

  #1、长度len

  注意群集的指标是将分歧的值存放到壹块,区别的聚合间用来做涉嫌运算,无需纠结于聚集中单个值

  #二、成员运算in和not in

#先期驾驭的操作:

  #3、&交集

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 #既报名linux又报名python的学生:交集
5 print(stus_linux & stus_python)
6 print(stus_linux.intersection(stus_python))
7 
8 #  值都是   {'alex', 'egon'}

  #1、长度len

  #4、|合集

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 #所有的学生:并集
5 print(stus_linux | stus_python)
6 print(stus_linux.union(stus_python))
7 
8 #值都是
9 #{'oldboy', 'egon', 'liudehua', '张全蛋', '李二丫', 'wxx', 'alex', '李铁蛋'}

  #二、成员运算in和not in

  #5、-差集

 1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
 2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
 3 
 4 #只报名linux,没有报名python的:差集
 5 print(stus_linux - stus_python)
 6 print(stus_linux.difference(stus_python))
 7 
 8 #值为 {'oldboy', '李铁蛋', '张全蛋'}
 9 
10 
11 #只报名python,没有报名linux的:差集
12 print(stus_python -  stus_linux)
13 print(stus_python.difference(stus_linux))
14 
15 #值为{'liudehua', '李二丫', 'wxx'}

  #3、&交集

  #陆、^对称差集

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 # 没有同时报名两门课程的学生姓名:交叉补集
5 print(stus_linux ^ stus_python)
6 print(stus_linux.symmetric_difference(stus_python))
7 
8 
9 #值都为 {'李铁蛋', '李二丫', 'oldboy', 'liudehua', '张全蛋', 'wxx'}

 

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 #既报名linux又报名python的学生:交集
5 print(stus_linux & stus_python)
6 print(stus_linux.intersection(stus_python))
7 
8 #  值都是   {'alex', 'egon'}

  #7、查看

1 s1={1,'a','b','c','d'}
2 
3 for item in s1:
4     print(item)
5 
6 #值的排序是随机的是上面五个元素的随机排序

  #4、|合集

  #8、增加

 1 s1={'a','b','c'}
 2 s1.add('d') # 一次添加一个值
 3 s1.add(4)
 4 print(s1)
 5  
 6 #值为{'a','b','c','d'}
 7 s1.update({3,4,5}) #一次添加多个值
 8 print(s1)
 9 
10 #值为{'a','b','c','d',3,4,5}   这里元素的顺序都是随机的

 

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 #所有的学生:并集
5 print(stus_linux | stus_python)
6 print(stus_linux.union(stus_python))
7 
8 #值都是
9 #{'oldboy', 'egon', 'liudehua', '张全蛋', '李二丫', 'wxx', 'alex', '李铁蛋'}

  #9、删除

 1 s1={'a','b','c'}
 2 #s1.discard() ## 当删除的元素不存在的时候,不会报错
 3 s1.discard(4)
 4 print(s1)            #值为{'a','b','c'}
 5 
 6 #s1.remove() # 当删除的元素不存在的时候,报错
 7 s1.remove(4)     #报错
 8 
 9 s1.pop() #随机取走一个元素
10 res=s1.pop()
11 print(res)       #值是随机的

  #5、-差集

  #10、父集,子集:

1 #父集:爹包含儿子
2 # s1={1,2,3}
3 # s2={1,2}
4 s1 > s2# 代表s1包含s2,s1是s2父集
5 s2 < s1 # s2是s1子集

 

 

 1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
 2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
 3 
 4 #只报名linux,没有报名python的:差集
 5 print(stus_linux - stus_python)
 6 print(stus_linux.difference(stus_python))
 7 
 8 #值为 {'oldboy', '李铁蛋', '张全蛋'}
 9 
10 
11 #只报名python,没有报名linux的:差集
12 print(stus_python -  stus_linux)
13 print(stus_python.difference(stus_linux))
14 
15 #值为{'liudehua', '李二丫', 'wxx'}

  #6、^对称差集

 

1 stus_linux={'alex','egon','张全蛋','李铁蛋','oldboy'}
2 stus_python={'李二丫','wxx','liudehua','alex','egon'}
3 
4 # 没有同时报名两门课程的学生姓名:交叉补集
5 print(stus_linux ^ stus_python)
6 print(stus_linux.symmetric_difference(stus_python))
7 
8 
9 #值都为 {'李铁蛋', '李二丫', 'oldboy', 'liudehua', '张全蛋', 'wxx'}

 

  #7、查看

1 s1={1,'a','b','c','d'}
2 
3 for item in s1:
4     print(item)
5 
6 #值的排序是随机的是上面五个元素的随机排序

  #8、增加

 1 s1={'a','b','c'}
 2 s1.add('d') # 一次添加一个值
 3 s1.add(4)
 4 print(s1)
 5  
 6 #值为{'a','b','c','d'}
 7 s1.update({3,4,5}) #一次添加多个值
 8 print(s1)
 9 
10 #值为{'a','b','c','d',3,4,5}   这里元素的顺序都是随机的

  #9、删除

 1 s1={'a','b','c'}
 2 #s1.discard() ## 当删除的元素不存在的时候,不会报错
 3 s1.discard(4)
 4 print(s1)            #值为{'a','b','c'}
 5 
 6 #s1.remove() # 当删除的元素不存在的时候,报错
 7 s1.remove(4)     #报错
 8 
 9 s1.pop() #随机取走一个元素
10 res=s1.pop()
11 print(res)       #值是随机的

  #10、父集,子集:

1 #父集:爹包含儿子
2 # s1={1,2,3}
3 # s2={1,2}
4 s1 > s2# 代表s1包含s2,s1是s2父集
5 s2 < s1 # s2是s1子集

 

群集,python-day5集结python全栈开荒-Day5 会集 壹、首先根据以下多少个点展开对聚焦的读书
#一:基本使用 一 、用途 二 、定义…

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website