#列表(List)
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推
Python有6个序列的内置类型,但最常见的是列表和元组,列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现,列表的数据项不需要具有相同的类型
1.列表的我的索引和切片
```python
mark = [100,'apple','banana',True,[1,2,3]]
#索引
print(mark[0],type(mark[0]))
print(mark[1],type(mark[1]))
print(mark[-1],type(mark[-1]))
#切片
print(mark[:2])
```
补充:创建列表的三种方式
-列表的创建方式一:
```python
list= [1,2,4]
print(list)
```
-列表的创建方式二:
```python
l1 = list('abc')
print(l1)
```
-列表的创建方式三:列表的推导式
2.列表的增删改查
1.列表的增
```python
mark = [100,'apple','banana',True,[1,2,3]]
#方法一:append方法,追加
mark.append('lion')
print(mark)
#误区:print(a.append('lion')) 错误打印,不可打印
#案例:
names = ["Bill","Mike","Jhon","Jack",]
while1:
name = input('请输新的员工的姓名(按Q或者q退出程序):')
ifname.upper() == 'Q':
break
print(names)
#方法二:insert 插入
mark = [100,'apple','banana',True,[1,2,3]]
mark.insert(3,'banana')
print(mark)
#方法三:迭代增加 extend
mark = [100,'apple','banana',True,[1,2,3]]
mark.extend('beatiful')
print(mark)
mark.extend(['tiger'])
print(mark)
```
2.列表的删除
```python
#法一:按照的索引位置删除
mark = [100,'apple','banana',True,[1,2,3]]
mark.pop(-2)#按照索引值删除(返回值是删除元素)
print(mark.pop(-2))
mark.pop()
print(mark)
#法二:remove()指定元素的删除(如有重名,默认删除从左数第一个)
mark = [100,'apple','banana','air','computer']
mark.remove('apple')
print(mark)
#方法三:clear 清空列表
mark = [100,'apple','banana','air','computer']
mark.clear()
print(mark)
#方法三:del
#第一种:del 按照索引值删除
mark = [100,'apple','banana','air','computer']
delmark[-1]
print(mark)
#第二种:按照切片删除
mark = [100,'apple','banana','air','computer']
delmark[::2]
print(mark)
```
3.列表的修改
```python
#法一:按照索引值修改
mark = [100,'apple','banana','air','computer']
mark[0] = "plane"
print(mark)
#法二:按照切片值进行修改
mark = [100,'apple','banana','air','computer']
mark[2:] ='pear'
print(mark)
#方法三:按照切片(步长)
mark = [100,'apple','banana','air','computer']
mark[::1] = 'mato'
print(mark)
```
3.列表的查询
```python
#按照索引,切片(步长)
mark = ['apple','pear','patao']
fori inmark:
print(i)
```
4.列表的嵌套(列表中包含着列表)
```python
#将列表中的apple 变成大写的状态并放回原处
mark[1] = 'APPLE'
print(mark)
#给列表mark追加一个元素为’老男孩教育‘
mark = [100,'apple','banana','air','computer']
print(mark[-1])
mark.append('老男孩教育')
print(mark)
#将列表mark中的’air‘通过字符串连接的方式在列表中变成’airplane‘
mark = [100,'apple','banana','air','computer']
print(mark[-1])
```
##元组(有序且不可更改的集合)
元组是圆括号编写的,元组只是只读列表,可以存大量的数据,可索引,切片(步长)
```python
mark = [100,'apple','banana','air','computer']
print(mark[0])
print(mark[:3])
#查看
fori inmark:
print(i)
#查看列表的长度
print(len(mark))
#可添加组
mark.append('supper')
print(mark)
#元组内元素是不可以删除的
delmark[0]
print(mark)
```
###range()
类似于列表,但是本身是数的范围列表,range()函数返回的是一个可迭代的对象(类型是对象),而不是列表类型,即打印时不会打印出来
```python
r = range(10)
fori inr:
print(i)
#索引
r = range(10)
print(r[1])
#案例
mylis = [1,2,3,'apple','Mike']
#利用for循环,range()将mylis列表内所有的元素索引依次打印出来
fori inrange(len(mylis)):
print(i)
```
##字典
字典是一个无序的,可变的和有索引的集合,在python中,字典是花括号编写的,拥有键值和(值是不可改变的数据类型)
why:列表可以储存大量的数据,数据之间的关联性不强;列表的查询速度比较慢
what:容量型数据:dict
how:数据类型的分类(可变与不可变):
可变(不可哈希)数据类型:list,dict,set
不可变(可哈希)数据类型:str, bool, int, tuple
```python
dict= {'水果':
{'apple','arangr','banana'},
'动物':
['pig','cat','bird'],
}
print(dict)
```
1.值可以是任意数据类型,对象
2.字典3.5x版本之前是无序的(包括3.5)
3.字典3.6x会按照初次建立的字典得到顺序排列,学术上不认为是有序的
4.字典3.7x以后都是有序的
5.字典的查阅速度是很快的,储存关联性强
6.以空间换时间
1.字典-增
dic['键']= 值
```python
'''
#没有键值对,增加
dic1 ={'age':18,'name':'xc','sex':'female'}
dic1['height'] = 165
print(dic1)
#没有键值对,则修改
dic1 ['age'] = 21
print(dic1)
#setdefault 设置默认
#没有键值对,增加
dic1 ={'age':18,'name':'xc','sex':'female'}
dic1.setdefault('weight',128)
print(dic1)
dic1.setdefault('name','acv')#有键值对,不做任何的操作
print(dic1)'''
```
2.字典--删除
删除优先使用pop(有返回值,要删除的内容不存在时不报错)而不是del
pop删除
```python
dic1 ={'age':18,'name':'xc','sex':'female'}
print(dic1.pop('age'))#有age直接删除----有返回值,按键直接删除
print(dic1)
print(dic1.pop('erge','没有此键值/None')) #没有erge---可设置返回值:没有此键/none
print(dic1)
```
popitem 随机删除 clear 清空 del 删除
```python
dic1 ={'age':18,'name':'xc','sex':'female'}
print(dic1.popitem())#随机删除:有返回值----返回元组:删除的键值
dic2 ={'age':18,'name':'xc','sex':'female'}
dic2.clear()
print(dic2)
dic3={'age':18,'name':'xc','sex':'female'}
deldic3['name']#有,则删除
deldic3['name1']#没有,则报错
print(dic3)
```
3.字典----改
```python
dic1 ={'age':18,'name':'xc','sex':'female'}
dic2 = {'name':'alex','weight':'168'}
dic2.update(dic1)#有则更新,没有则增加
print(dic1)
print(dic2)
```
4.字典--查
keys, values, items
```python
dic1 ={'age':18,'name':'xc','sex':'female'}
print(dic1.keys(),type(dic1.keys())) #结果:键->dict_keys(['age', 'name', 'sex'])
print(dic1.values())#结果:值->dict_values(['female', 18, 'xc'])
print(dic1.items())#结果:元组->dict_items([('age', 18), ('sex', 'female'), ('name', 'xc')])
```
得到键值,首选get
```python
dic3={'age':18,'name':'xc','sex':'female'}
print(dic3['age'])#有,则打印
#print(dic3['age1'])#没有,则报错
print(dic3.get('name'))#有name直接输出----有返回值
print(dic3.get('name1','没有此键值'))#没有name1---可设置返回值,没有此键值
```
循环输出
```python
dic1 ={'age':18,'name':'xc','sex':'female'}
fori indic1:
print(i)#循打印键(默认为键)
fori indic1.keys():
print(i) #循环打印键值
fori indic1.values():
print(i) #循环打印值
fori indic1.items():
print(i) #循环打印键值对
fork,v indic1.items():
print(k,v)#打印键和值
```
5.字典的嵌套
```python
dic = { 'name':['alex','kobe','Mike'],
'py9':{
'time':'123',
'study_fee':12908,
'addr':'CBD'
},
'age':32
}
dic['age'] = 56#找到age,在更新为56
print(dic)
dic['name'].append('god')#找到name在添加名字
print(dic)
dic['name'[1]] = dic['name'][1].upper()#找到name,在把第一个name变成大写
print(dic)
dic['py9']['female'] = 6#找到元组,增加键值对female:6
print(dic)
```
```
#应用案例:输入一串字符,遇到字母,转换为“_”,并打印输出
info = input('请输入:')
for i in info:
if i.isalpha():
info = info.replace(i,'_')
print(info)
```
###集合
集合类似于列表,但每个元素都必修是独一无二的,且不可变的,同时它也是无序的
基本操作
```python
set= {1,2,3,4}
#set2 = {1,2,3,[1,2,3,4],{'name':'Kitten'}}#列表是不可哈希的,所以报错
print(set)
#print(set2)
```
1.集合---增加
add, update
```python
set1 = {'mike','james','rigibody','box','apple'}
set1.add('sunday') #因为集合是无序的,所以每次运行的结果不一定不一样,增加的位置也不一样
print(set1)
set1.update('rainday')#迭代增加,依然是无序的
print(set1)
```
2.集合---删
```python
set1 = {'mike','james','rigibody','box','apple'}
#pop----随机删除
print(set1.pop())#有返回值,返回删除本次的内容
#remove----指定元素删除
set1.remove('mike')
print(set1)
#clear---清空
set1.clear() #空集合
print(set1)
#del 删除
delset1 #删除集合后集合不存在,出现报错
print(set1)
```
3.集合是不能更改的
集合是无序的,集合中的元素是不可变的数据类型
4.集合----查
```
set1 = {'mike','james','rigibody','box','apple'}
for i in set1:
print(i)
```
5.集合之间的操作
```python
set1 = {1.2324,234,3,23,7,5,6,4336,6464,234543,232,34}
set2 = {1,2,3,4,45,65,7,6575,658,5686,8678,678,232}
print(set1 & set2)#集合的交集
print(set1.intersection(set2))#集合的交集
print(set1 | set2)#集合的并集
print(set1.union(set2))#集合的并集
#反交集---除交集以外的其他元素
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
#差集--前者独有的
print(set1 - set2)
print(set1.difference(set2))
print(set2 - set1)
print(set2.difference(set1))
#子集与超集
set3 = {1,2,3,4}
set4 = {1,2,3,4,5,6,7,8,8,9}
print('--------set3是set4的字集----------')
print(set3
print(set3.issubset(set4))
print('---------set4是set3的超集---------')
print(set4 > set3)
print(set4.issuperset(set3))
```
##公共方法
排序
```python
#正向排序:sort()
li = [1,3,35,4,23,6,7,567,865,9,232]
li.sort()
print(li)
#倒序排序:li.sort(reverse = True)
li1= [1,3,35,4,23,6,7,567,865,9,232]
li1.sort(reverse=True)
print(li1)
#反转:li.reverse()
li2= [1,3,35,4,23,6,7,567,865,9,232]
li2.reverse()
print(li2)
```
####补充
字符串列表排序----根据字符串的第一个字符对应的ASCII码排序
```python
li = ['adc','abc','adv','hdc']
li.sort()
print(li)
#count()元素出现的次数
mylist =['xscd','cdc','木木',[1,2,3],'eight','木木']
num = mylist.count('木木')
print(num)
#len()计算列表的长度
mylist1 =['xscd','cdc','木木',[1,2,3],'eight','木木']
l = len(mylist1)
print(l)
#mylist.index('元素') 查看索引
mylist3 =['xscd','cdc','木木',[1,2,3],'eight','木木']
print(mylist3.index('木木'))
```
####区别和异同
| | 列表list | 元组tuple | 集合set | 字典dict |
| -------- | -------- | --------- | ------------------ | ---------------------- |
| 可否读写 | 读写 | 只读 | 读写 | 读写 |
| 可否重复 | 是 | 是 | 否 | 是 |
| 储存方式 | 值 | 值 | 键(不可重复) | 键值对(键的不能重复) |
| 是否有序 | 有序 | 有序 | 无序 | 自动正序 |
| 初始化 | [1,'a']| (‘a’,1) | set([1,2])或{1,2} | {'a',1,'b',2} |
| 添加 | append | 只读 | add | d['key']='value' |
| 读元素 | l[2:]| t[0]| 无 | d['a']|