4天学会python_学python 第四天

#列表(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']|