2018-11-22 python学习第七天

Posted 2021-01-21

#列表类型

======================================基本使用======================================

1、用途：记录多个值（同种属性）

2、定义方式：在[]内用逗号分隔开多个任意类型的值

l=[‘a‘,‘b‘,‘c‘] #l=list([‘a‘,‘b‘,‘c‘])

类型转换

l=list(‘hello‘)

l=list({‘x‘:1,‘y‘:2}) #将字典转换为列表

print(l)

3、常用操作+内置的方法

#优先掌握的操作：

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

1、按索引存取值(正向存取+反向存取)：即可存也可以取

print(l[0]) #读取列表内第一个元素

print(l[-1]) #读取列表内最后一个元素

print(id(l))

l[0]=‘A‘ #说明列表是可变的，元素改变，但是保存在内存中的ID号不变

print(id(l))

l[4]=‘EEEEEE‘ #改变列表中最后一个元素的值

print(l)

l[5]=‘dddddd‘ #列表中不能添加新的值

#2、切片(顾头不顾尾，步长)

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

print(l[1:4]) #列表切片，这里得到的值是b,c,d

print(l)

#

#3、长度

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

print(len(l)) #查看列表内有几个元素这里是5个

#4、成员运算in和not in

print(‘a‘ in l) #查看a这个字符是不是在列表内

print(‘ssssss‘ not in l) #ssss这个元素不在l内， not in 所以也是TrUE

#5、追加&插入

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

l.append(3333333) #append 是添加的意思，在最后的尾部添加

l.append(44444)

print(l) #所以这里打印的值为a,b,c,d,e,33333333333,444444

#

l.insert(0,11111111111) #inser是插入的意思，这里0就是首部插入字符为111111111111

print(l) #打印的结果为 [11111111111, ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]

#

6、删除

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

del l[0] #del是删除的意思，这里删除的是a这个元素

res=l.remove(‘b‘) #remove是移除的意思，这里可以使用字符表示不需要根据索引来删除

print(l)

print(res)

res=l.pop(0) #pop默认是从 首部开始的 如果想尾部删除就使用-1

print(l)

print(res)

#

#7、循环

l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

for item in l: #for循环打印列表内的元素

print(item)

#需要掌握的操作

l=[‘a‘,‘b‘,‘a‘,‘c‘,‘d‘,‘e‘]

print(l.count(‘a‘)) #count是统计列表内a这个元素在列表内有多少个

l=[‘a‘,‘b‘,‘a‘,‘c‘,‘d‘,‘e‘]

items=[1,2,3,4,5]

for item in items:

l.append(item) #for循环来依次吧items内的值添加到l内并打印出来

#

l.extend(items) #这里的话extend一条命令就能完成for循环的操作，extend是延申的意思

print(l)

l=[‘a‘,‘b‘,‘a‘,‘c‘,‘d‘,‘e‘]

print(l.index(‘a‘,2,5)) #index是查看a这个元素所在的列表内的位置! 2,5的意思就是从第二索引查到第五索引的位置

l.index(123123123123123123123123)

if 123123123123123123123123 in l:

print(l.index(123123123123123123123123))

l=[‘a‘,‘b‘,‘a‘,‘c‘,‘d‘,‘e‘]

l.reverse() #reverse的意思就是吧列表内的元素全部倒过来

print(l)

#

l=[10,-1,3,11,9]

l.sort(reverse=True) #sort是从小到大排序，但是()内添加了reverse=True时就是反转，从大到小排序

print(l)

print(l.extend([‘a‘,‘b‘,‘c‘])) #直接吧a,b,c添加到l的列表内

print(l.pop(0)) #删除第一个元素

print(l)

======================================该类型总结====================================

存多个值

有序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

练习题

#1. 队列：先进先出 #队列就是 吃了就啦 的意思，啦出来肯定是最先吃进去的

l=[] #定义一个空列表

入队

l.append(‘first‘) #添加第一个元素

l.append(‘second‘) #添加第二个元素

l.append(‘third‘)

print(l)

出队

print(l.pop(0)) #取出第一个元素 这个时候是first为第一个

print(l.pop(0))

print(l.pop(0))

2. 堆栈：后进先出 #堆栈就是吃了多了呕吐了，吐出来的肯定是最后吃进去的东西

l=[]

入栈

l.append(‘first‘)

l.append(‘second‘)

l.append(‘third‘)

print(l)

出栈

print(l.pop()) #去除最后一个元素，这个时候是third

print(l.pop())

print(l.pop())

元组tuple：

======================================基本使用======================================

1、用途：元组就是一个不可变的列表

2、定义方式：在()内用逗号分隔开多个任意类型的元素

t=(1,2.2,‘aa‘,(‘b‘,‘c‘),[‘a‘,‘b‘,‘c‘]) # t=tuple(...)

print(type(t)) #查看元祖类型为tuple

强调：

l=[‘a‘]

print(type(l),l[0]) #元祖也可以通过标识符来取值

#

t=(‘a‘,)

print(type(t)) #只要元祖内有个逗号，他就是元祖，没有逗号光一个值他就是字符串

print(t)

msg=(‘hello world‘) #这个就是字符串，一个不是元祖

类型转换

t1=tuple(‘hello‘) #将字符串转换为元祖

t2=tuple([1,2,3]) #将列表转化为元祖

print(t1)

print(t2)

3、常用操作+内置的方法

#优先掌握的操作：

t=(1,2.2,‘aa‘,(‘b‘,‘c‘),[‘a‘,‘b‘,‘c‘])

1、按索引取值(正向取+反向取)：只能取

print(t[0]) #元祖正向取值根据索引去第一个为1

print(t[-1]) #元祖方向取值根据定位符取最后一个值 他是[‘a‘, ‘b‘, ‘c‘]

#

t[0]=1111111111

#2、切片(顾头不顾尾，步长)
t=(‘a‘,‘b‘,‘c‘,‘e‘,‘f‘)

print(t[1:4]) #元祖切片，切出来的是‘b‘,‘c‘,‘e‘

#3、长度

print(len(t)) #显示元祖内有几个元素

#4、成员运算in和not in

print(‘a‘ in t)

#5、循环

for item in t:

print(item)

需要掌握的操作

t=(‘a‘,‘b‘,‘c‘,‘e‘,‘a‘,‘f‘)

print(t.index(‘a‘,1,5)) #index是索引的意思，定义a 在这个元祖内的位置! 1,5是在第一位置到第五位置去查找

print(t.count(‘a‘)) #count是统计这个a元素在元祖内有多少个

======================================该类型总结====================================

存多个值

有序

不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

t=(‘a‘,‘b‘,‘c‘)

print(id(t))

t=(‘A‘,‘B‘,‘C‘)

print(id(t)) #这里表示的是元祖是不可变的

#字典类型dict

======================================基本使用======================================

1、用途:记录多个值,列表是索引对应值,而字典是key对应值,其中key对value有描述性的功能

2、定义方式:在{}用逗号分隔开多个元素,每个元素都是key:value的形式,其中key可以不可变类型,通常是字符串类型

而value可以是任意类型

d={1:‘aaa‘,2.2:‘bbb‘,‘xxx‘:‘ccc‘,(1,2,3):‘dddd‘} #d=dict(...)

print(d[(1,2,3)]) #字典取值的方式，如果要取多个 print(d[1],d[‘xxx‘])

类转换

d=dict(x=1,y=2,z=3) #这也是一次生成字典的方式

print(d)

items=[(‘name‘,‘egon‘),(‘age‘,18),(‘gender‘,‘male‘)] #这也是字典生成的一种方式

d={}

for item in items:

d[item[0]]=item[1]

d=dict(items) #这dict是字典生成的方式

print(d)

了解

keys=[‘name‘,‘age‘,‘gender‘,‘height‘,‘weight‘]

d={}

for key in keys:

d[key]=None

#

d={}.fromkeys(keys,None) #fromkeys是生成value的关键词

print(d,type(d)) #生成的信息是{‘name‘: None, ‘age‘: None, ‘gender‘: None, ‘height‘: None, ‘weight‘: None}

#

3、常用操作+内置的方法

#优先掌握的操作：

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

dic={‘name‘:‘egon‘,‘age‘:18}

print(dic[‘name‘])

dic[‘name‘]=‘EGON‘

dic[‘gender‘]=‘male‘ #字典是可以改变vale 并可以添加新的key 和value进去

print(dic)

l=[‘a‘,‘b‘,‘c‘]

l[0]=‘A‘

l[4]=‘AAA‘

#2、长度len

dic={‘name‘:‘egon‘,‘age‘:18}

print(dic)

print(len(dic)) #字典统计长度是统计key有几个的

#3、成员运算in和not in :是以字典的key为准的

dic={‘name‘:‘egon‘,‘age‘:18}

print(‘name‘ in dic)

print(‘egon‘ in dic)

#4、删除
dic={‘name‘:‘egon‘,‘age‘:18}

del dic[‘name‘]

print(dic)

res=dic.pop(‘name‘)

print(dic) #字典用pop删除字典key ，可以打印出来key对应的value的值

print(res)

res=dic.popitem() #popitem是删除key和value的值 并且可以打印出来，删除的内容

print(res)

#5、键keys()，值values()，键值对items()

在python2

>>> dic={‘name‘:‘egon‘,‘age‘:18}

>>>

>>>

>>> dic.keys()

[‘age‘, ‘name‘]

>>>

>>>

>>> dic.values()

[18, ‘egon‘]

>>>

>>>

>>> dic.items()

[(‘age‘, 18), (‘name‘, ‘egon‘)]

在python3

>>> dic={‘name‘:‘egon‘,‘age‘:18}

>>>

>>> dic.keys()

dict_keys([‘name‘, ‘age‘])

>>> dic.values()

dict_values([‘egon‘, 18])

>>> dic.items()

dict_items([(‘name‘, ‘egon‘), (‘age‘, 18)])

#6、循环
dic={‘name‘:‘egon‘,‘age‘:18}
for k in dic: #默认是打印key
print(k)

for k in dic.keys(): #这个是后面指定打印key值
print(k)

for v in dic.values(): #这个是指定打印value的值
print(v)

for k,v in dic.items(): #k,v=(‘name‘, ‘egon‘) #当使用.items时， 前面需要使用2个值来对应,这样可以同时打印出key，和value的值
print(k,v)

======================================该类型总结====================================

存一个值or存多个值

有序or无序

可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

pythons=[‘张铁蛋‘,‘李铜淡‘,‘王金蛋‘,‘赵银胆‘,‘alex‘,‘kevin‘]

linuxs=[‘oldboy‘,‘张铁蛋‘,‘赵银胆‘,‘alex‘,‘wxx‘]

#

res=[]

for stu in pythons:

if stu in linuxs:

res.append(stu)

#

print(res)

集合类型set

======================================基本使用======================================

1、用途:I: 关系运算 II:去重

2、定义方式:在{}内用逗号分隔开多个元素,但是元素的特点是

I: 集合内的元素必须是不可变类型

II: 集合内元素无序

III: 集合内元素不能重复

s={1,‘aaa‘,2,} #s=set(...)

print(s,type(s))

s=set()

print(s,type(s))

s={1,1,1,1,1,1,1,1,1,1,1,1,‘a‘,‘a‘,‘a‘} #集合有去重复的意思，这里显示只有{1,‘a‘}

print(s)

数据类型转换

res=set(‘hello‘) #吧字符串变为集合显示的为{‘l‘, ‘h‘, ‘e‘, ‘o‘} 因为集合是无序的，去重所以少了个l

print(res)

res=set([1,‘a‘,‘b‘]) #吧列表转换为集合，显示为{1, ‘b‘, ‘a‘}

print(res)

3、常用操作+内置的方法

#优先掌握的操作：
#1、长度len
#2、成员运算in和not in

pythons={‘张铁蛋‘,‘李铜淡‘,‘王金蛋‘,‘赵银胆‘,‘alex‘,‘kevin‘}
linuxs={‘oldboy‘,‘张铁蛋‘,‘赵银胆‘,‘alex‘,‘wxx‘}
#3、|合集:求所有报名的学生

print(pythons | linuxs) # | 这个是让几个元祖 合集

print(pythons.union(linuxs))

#4、&交集:求同时报名两门课程的学生

print(pythons & linuxs) # & 这个是显示交集 显示的是{‘alex‘, ‘张铁蛋‘, ‘赵银胆‘} 因为他们都报了2们课程

#5、-差集: 求只报名python课程的学员

print(pythons - linuxs) # - 这个是差集 是让2个元祖内的元素相减

print(linuxs - pythons) #求只报名linux课程的学员

#6、^对称差集:求没有同时报名两门课程的学生

res=(pythons - linuxs) | (linuxs - pythons)

res=pythons ^ linuxs # ^对称差集

print(res)

#7、==

s1={1,2,3}

s2={3,2,1}

print(s1 == s2)

注意:父子集描述的是一种包含与被包含的关系

#8、父集：>= #>= 父集就是包含的意思
#9、子集：<=

s1={1,2,3}

s2={1,2,3,4}

print(s2 >= s1)

print(s1 <= s2)

需要掌握的

s1={1,2,3}

s1.update({3,4,5,6}) #update是更新的意思，就是添加元素到集合内{1, 2, 3, 4, 5, 6}

print(s1)

s1={1,‘aa‘,‘bb‘,3}

print(s1.pop())

#

res=s1.remove(‘bbbbbb‘)

print(s1)

print(res)

s1.discard(‘bbb‘)

s1.add(4)

print(s1)

======================================该类型总结====================================

存多个值

无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

集合的去重

局限性

#1. 只能针对不可变类型
#2. 不能保证原来的顺序

names=[‘egon‘,‘egon‘,‘egon‘,‘alex‘,‘alex‘,‘kevin‘]

new_names=list(set(names))

print(new_names)

l=[
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
{‘name‘:‘kevin‘,‘age‘:20,‘sex‘:‘female‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
{‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)

print(new_l)