今日内容

list列表类型常用方法

用[ ]来书写

l = [1,2,3,4,5,6,7]

1.clear 清除

l.clear()
print(l)
res = l.clear()
print(l)
print(res)

2.reverse 将列表反转

l.reverse
reverse()
print(l)

3.sort 排序，默认情况下是从小到大（升序）

l.sort()
l1 = [43,6,1,7,99]
l1.sort(reverse=True) '''可以通过指定参数来修改默认的排序规则'降序' '''
print()

'''

能存多个值

有序的

可变类型

'''

队列（先进先出）

l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 先出
l1.pop(l1.pop(0))
l1.pop(l1.pop(0))
l1.pop(l1.pop(0))

队列

堆栈（先进后出）

l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 后出
l1.pop(l1.pop())

堆栈

元祖

作用：能够存储多个元素，元素与元素之间逗号隔开，元素可以是任意类型，元祖不能被修改。

定义：与列表类型比，只不过是[ ]变成了( )

t = (1,2,3,'a','b',[1,2,3])
print(type(t)) '''<class 'tuple'>'''
t1 = tuple(1) '''报错，是因为必须传容器类型'''

n = (1)
print(type(n)) '''<class 'int'> '''

n = ('a')
n1 = (1)
print(type(n),type(n1))

''' <class 'str'> <class 'int'>

在定义容器类型的时候，哪怕内部只有一个元素，你也要用逗号隔开，区分一下

'''

优先掌握的操作：

1.按索引取值（正向+反向取值）：只能取值

t = (1,2,3,'a','b',[1,2,3])
print(t[0])

t[1] = 'hahah'   
'''报错，元祖本身不可变，除list、dict中指定的值可变'''
t[-1] = 'hahaha'  
'''报错，元祖本身不可变，且元祖中所有类型的单个元素都不可变'''

t[-1][0]= '我改了'
print(t)   '''(1, 2, 3, 'a', 'b', ['我改了', 2, 3])'''

2.切片（顾头不顾尾）

python day6中已经提到过

t=(1,2,3,4,5)
print(t[0:3])
'''(1, 2, 3)'''
print(t)
'''(1, 2, 3, 4, 5)'''

3.长度len()：计算元组元素个数

print(len(t))

4.成员运算in和not in

python day6中已经提到过

5.循环

for item in ('a','b','c'):
    print(item)
'''
a
b
c
'''

元祖的内置方法

print(t.count(‘a’)) '''计数'''

print(t.index(‘XXX’)) '''索引'''

'''

能存多个值

有序

不可变

'''

字典

用 { } 来书写

作用：能存储多个”值“，比如key:value键值对，key是对value的描述，key通常情况下都是字符串，其实这个key只能是不可变类型，value可以是任意数据类型

定义：

d = {'name:'jason','password':123}
''' d = dict{‘name’:‘jason’,‘password’:123} '''
d1 = {1:'1',0:'0',1.11:'1.11'}
print(d1[1.11]) 
''' 1.11 '''
print(type(d1)) 
''' <class 'dict'> '''
d2 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢?'}
print(d2[(1,2)]) 
''' 到底能不能呢? '''
d3 = {'name:'jason','name:tank,'name:'nick','password':123}

'''

print(d3)

输出结果为{name:'nick','password':123} 

'''

强调：字典的key是不能重复的，要唯一标识一条数据；如果重复了，只会按照最后一组重复的键值对存储

优先掌握的操作：

1.按key值存取值：可存可取

d3 = {'name':'jason','password':123}
print(id(d3))
print(d3['name'])
d3['name'] = 'egon'
d3['age'] = 18  # 赋值语句当key不存在的情况下，会自动新增一个键值对
print(d3,id(d3))

2.count：统计的是键值对的个数

3.成员运算in和not in（对于字典来说只能判断key值，value无法判断）

d3 = {'name':'jason','password':'123'}
print('123' in d3)   '''False'''
print('name' in d3)   '''True'''

4.删除

d3 = {‘name’:‘jason’,‘password’:’123’}
del d3[‘name’]
print(d3) # {‘password’:‘123’} 

d3 = {‘name’:‘jason’,‘password’:’123’}
d3.pop(‘name’)
print(d3) # {‘password’:‘123’}

res = d3.pop(‘name’)
print(res) # jason 弹出的仅仅是value 
res = d3.pop(‘age’)
print(res) # 直接报错 因为字典中没有‘age’
print(d3)

定义字典的三种方式：

d1 = {‘name’:‘jason’,’password’:123}
d2 = dict(name=‘jason’,password=123,age=18)
print(d2,type(d2))

下面这种方式了解即可：

l = [
[‘name’,‘jason’],
[‘age’,‘18’],
[‘hobby’,‘read’]
]
d = {}
for i in l:  #[‘name’,‘jason’],[‘age’,18],.......
d[i(0)] = i[l]
for k,v in l:
 # k,v = [‘name’,‘egon’] 

d(k) = v
print(d)
d3 = dict(l)
print(d3)

内置方法：

键keys(),值values(),键值对items()

d1 = {‘name’:‘jason’,‘password’:123}
print(d1.keys()) # dict_keys([‘name’, ‘password’])
''' 与for k in d1.keys():
print(k) 相似
'''
print(d1.values()) # dict_values([‘jason’,123]) 现在就把它当成一个列表来看就行了
print(d1.items()) # dict_items([‘name’,‘jason’]) 就把它当成一个元祖来看,元祖的第一个元素就是字典的key，第二个元素是字典的value

dict.get()

get()根据key来获取value

d1 = {‘name’:‘jason’,‘pwd’:123}
# print(d1[‘name’]) ；print(d1[‘age’]) 这两种方式不太推荐 
print(d1.get(‘name’)
res = d1.get(‘age’)  # 当字典的key不存在的情况下，不报错而返回None
res1 = d1.get(‘age’,‘你给我的age在字典的key中’)  # 当字典的key不存在的情况下，不报错，返回None 

''' get可以传第二个参数，当你的key不存在的情况下，返回第二个你写好的参数信息 '''

print(res1)
print(d1.get(‘XXX’,‘XXXXX’))    # 第二个参数不写的话，返回None 
print(res)

dict_fromkeys()快速的创建一个字典

print(d1.fromkeys(‘name’))  #{‘n’:None,‘a’:None,‘m’:None,‘e’:None} 
l1 = [‘name’,‘password’,‘age’,‘hobby’]
print(dict.fromkeys(l1,123))

dict_popitem()从尾部以元祖的形式弹出键值对

print(d1.popitem())  # (‘pwd’,123) 
print(d1.popitem())  # (‘name’,‘jason’)

dict_setdefault()

d1 = {‘name’:‘jason’,‘pwd’:123}
res1 = d1.setdefault(‘name’,‘XXOO’)  # 当键存在的情况下，不修改值，并且将原先key对应的值返回给你
print(d1,res1)
res2 = d1.setdefault(‘age’,18)  # 当键不存在的情况下，新增一个键值对，并且将新增的键值对的值返回给你 
print(d1,res2)

dict_update

d1 = {‘name’:‘jason’,‘pwd’:123}
d2 = {‘age:‘18’}
d1.update(d2)
print(d1)  # {‘name’:‘jason’,‘pwd’:123,‘age:‘18’} 

d1 = {‘name’:‘jason’,‘pwd’:123}
d1.update(age=18)
print(d1)  # {‘name’:‘jason’,‘pwd’:123,‘age:‘18’}

‘’‘

存多个值

无序

可变类型

’‘’

集合

也是用 { } 书写，不过要注意与字典进行区分

群体之间作比较，不涉及单个元素

作用：

1.关系运算
2.去重复，去冗余

定义集合：可以包含多个元素，用逗号分割

s = {1,2,3,4,5,6}
print(type(s))  # <class ‘set’> 
s1 = set()
print(type(s1))  # 注意在定义空集合时，只能用set() 

x = {}
print(type(x))  # <class ‘dict’> 如果你仅仅只写了一个大括号，那么python默认将它当做字典类型 

t = ()
print(type(t))  # <class ‘tuple’>

集合的元素遵循三个原则：

1.每个元素必须时不可变类型

　　　　可变：不可hash

　　　　不可变：可hash

　　例如：

s = {1,2,3,4,5,6,‘a’,(1,2),[1,2]}  # 报错 

s = {1,2,3,4,5,6,‘a’,(1,2),{‘name’:‘jason’}}  # 报错

2.没有重复的元素

s = {1,2,2,2,2,2,2,,2,2,3,3,3,,3,3,4,,4,4,4,5,6}
print(s)   # s = {1,2,3,4,5,6}  自动将重复的元素去除
l = {‘jason’,‘jason’,‘egon’}
print(l)   # [‘jason’,‘egon’]   自动将重复的元素去除

3.无序（不支持索引取值）

s = {1,2,3,4,5,6}
print(s[1])  # 报错

注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

常用操作+内置的方法

pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'} 
linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'} 

取及报名python课程又报名linux课程的学员:交集 
print(pythons & linuxs) 
print(pythons.intersection(linuxs))

取所有报名老男孩课程的学员:并集 
print(pythons | linuxs) 
print(pythons.union(linuxs))

取只报名python课程的学员: 差集 
print(pythons - linuxs) 
print(pythons.difference(linuxs))

取只报名linux课程的学员: 差集 
print(linuxs - pythons) 
print(linuxs.difference(pythons))

取没有同时报名两门课程的学员:对称差集 
print(pythons ^ linuxs) print(pythons.symmetric_difference(linuxs))

是否相等 
s1={1,2,3} s2={3,1,2} 
print(s1 == s2)

父集:一个集合是包含另外一个集合 
s1={1,2,3} s2={1,2} 
print(s1 >= s2) 
print(s1.issuperset(s2))
或
s1={1,2,3} 
s2={1,2,4} 
print(s1 >= s2)

子集:一个集合是否被另外一个集合包含
s1={1,2,3} 
s2={1,2} 
print(s2 <= s1) 
print(s2.issubset(s1))

s = {1,2,3,4,5}
s2 = {1,2}
print(s >= s2)  #True s是否包含s2 

s = {1,2,3,4,5}
s2 = {1,2,6}
print(s >= s2)  # False s是否包含s2

需要掌握的操作

s1={1,2,3} 
s1.update({3,4,5}) 
print(s1)

s1={1,2,3} 
res=s1.pop() 
print(res)

s1={1,2,3} 
res=s1.remove(3)  #单纯的删除,返回值为None
print(s1)

s1={1,2,3} 
s1.add(4) 
print(s1)

s1={1,2,3} 
s2={1,2} 
s1.difference_update(s2)  #s1=s1.difference(s2)
print(s1)

s1={1,2,3} 
res=s1.discard(3)  #单纯的删除,返回值为None
print(s1) 
print(res) 
s1.remove(444444)  #删除的元素不存在则报错 
s1.discard(444444)   #删除的元素不存在不会报错

s1={1,2,3} 
s2={1,2,4} 
print(s1.isdisjoint(s2))   #如果两个集合没有交集则返回Tru

s1={1,2,3} 
s2={4,5,6} 
print(s1.isdisjoint(s2))   #如果两个集合没有交集则返回True

'''

可以存多个值

无序

set可变

'''

s={1,2,3}
print(id(s))  #2453503268232
s.add(4)
print(id(s))  #2453503268232

集合去重

局限性

1、无法保证原数据类型的顺序
2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重

names=['alex','egon','alex','alex','egon','lxx'] 
s=set(names) 
print(s) 
l=list(s) 
print(l)

stus_info=[ {'name':'egon','age':18}, 
{'name':'alex','age':73}, 
{'name':'oldboy','age':84}, 
{'name': 'egon', 'age': 18}, 
{'name': 'egon', 'age': 18}, 
{'name': 'egon', 'age': 18}, 
{'name': 'oldboy', 'age': 84},
] 
# 如果输入set(stus_info)就会报错，因为stus_info是可变类型数据 
l=[] 
for info in stus_info: 
　　if info not in l: 
　　l.append(info)

stus_info=l 
print(stus_info)

原文地址：https://www.cnblogs.com/zhukaijian/p/11133783.html

python day7

今日内容

list列表类型常用方法

元祖

字典

内置方法：

集合

集合的元素遵循三个原则：

需要掌握的操作

集合去重

局限性