Python学习—day1

学习python打卡day1

此次学习的内容链接
链接: https://zhuanlan.zhihu.com/p/29452562
https://zhuanlan.zhihu.com/p/31582406
https://zhuanlan.zhihu.com/p/31843146

python里的各种容器，有列表、字典、元组等

列表

列表的三大特点：

1. 异构性 ：列表里可以包含各种类型和种类的对象
   如L=[1,2,“day”,[2,3],“hello”]；
2. 有序性 ：列表里的元素是有顺序的，因而可按照位置序号获取单个元素，也可用分片的方法获取多个连续元素
   #列表中的元素的序号从0开始，左边第1个的索引值是0，第2个的索引值是1，另外右边数起第一个是-1，第二个是-2。索引值引用时是左闭右开。
   L=[1,2,3,4,5,6,7,8]
   ①截取单个元素
   print(L[1]) #第2个元素
   2
   ②连续截取多个元素
   print(L[1:2]) # 第2个元素
   2
   print(L[1:]) #省略掉终止索引，就截取到最后
   [2,3,4,5,6,7,8]
   print(L[:4]) #省略掉起始索引，就从开头截取
   [1,2,3,4]
   print(L[4:-1]) #负索引
   [5,6,7]
   ③跳跃截取元素
   设置步进值参数，上面的连续截取元素步进值参数都是1
   print(L[0::2) #此时的步进值参数就为2，省略了终止索引（若步进值是默认的1，此时输出的结果应该是[1,2,3,4,5,6,7,8]）
   [1,3,5,7]

分片索引参考链接：https://blog.csdn.net/marraybug/article/details/85163484

*ps:对原始列表进行分片切割后，获取了新的列表，此时对新的列表进行修改，不会影响到原始列表*；

3. 本地可修改：列表的大小和内容可以在原有列表上直接修改，不是返回修改后的新列表L=L.insert(6,2)这是错误的。insert的返回值是None
   添加：append为在尾部加入，insert可在任意部位加入（倘若指定的索引值大于序列的总长度，默认加到列表末尾），extend可在尾部一次性加入多个元素
   ①L=[1,2,3,4]
   L.append(5)
   print(L)
   [1,2,3,4,5]
   ②L=[1,2,3,4]
   L.insert(1,10) #前面的数字是要新插入的元素的索引值为1，即第2个元素的位置，10是要插入的新元素
   print(L)
   [1,10,2,3,4]
   ③L=[1,2,3,4]
   L.extend([11,22,33,44])
   print(L)
   [1,2,3,4,11,22,33,44]
   删除：remove，传入要删除的对象即可；内置方法del还可以删除列表中的分片；pop可以在末端删除一个元素，并且将删除元素作为返回值返回给调用者（返回删除的元素）
   ①L=[‘aa’,‘bb’,‘cc’]
   L.remove(‘aa’)
   print(L)
   [‘bb’,‘cc’]
   ②L=[‘aa’,‘bb’,‘cc’]
   del L[1:2]
   print(L)
   [‘aa’,‘cc’]
   ③L=[‘aa’,‘bb’,‘cc’]
   print(L.pop()) #在列表末端删除一个元素，并且返回删除的值
   print(L)
   cc
   [‘aa’,‘bb’]
   修改：直接用索引做元素修改；分片赋值(本质是在原列表上删除指定分片，再在删除的位置上插入新的列表，左右两边元素的个数可以不等)；本地排序sort升序，reverse降序
   ①L=[1,2,3,4]
   L(0)=0
   print(L)
   [0,2,3,4]
   ②L=[1,2,3,4]
   L[1:3]=[‘aa’,‘bb’,‘cc’,‘dd’] #将原列表中索引值为1和2的元素替换
   print(L)
   [1,‘aa’,‘bb’,‘cc’,‘dd’,4]
   ③L=[1,5,4,2,3]
   L.sort()
   print(L)
   L.reverse()
   print(L)

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

字典

与列表不同，字典里的对象是无序的，通过一对对的键和值来反映一种映射关系。字典里要通过唯一的键来存取对应的值，不能像列表通过位置索引。
字典也具有异构性。

1对字典的读取及修改

D={'food':'spam','quality':4,'color':'pink'}
print(D['food']) #用‘food’键读取对应的值——字符串对象‘spam’
D['sex']='gender' 增加'sex'键及对应的值，也可以原地修改（？）
print(D)

spam
{'food':'spam','color':'pink','quality':4,'sex':'gender'}

2生成字典的其他方法
①初始为空字典，动态补充新的键和值

D={}
D['name']='Bob'
D['jib']='dev'
print(D)
    
{'name':'Bob','job':'dev'}

②用列表动态生成字典☆
一般来说字典的键是事先设定好的，值是要在程序运行过程中通过用户输入、网页抓取等不同手段动态获得的。获取值列表后可以动态生成一个字典。

key_list=['a','b','c']
value_list=[11,22,33]
D=dict(zip(key_list,value_list))
print(D)

{'a':11,'c':33,'b':22}

③用键值对元组组成的列表构造字典
（元组就是这个圆括号）

D=dict([('aa':11),('bb':22),('cc':33)])
print(D)

{'cc':33,'aa':11,'bb':22}

3合并两个字典

D1={'a':1,'b':2,'c':3}
D2={'c':8,'d':9}
D1.update(D2)      #倘若两个字典里有一样的键，但值不同，会进行无规律覆盖
print(D1)

{'c':8,'b':2,'a':1,'d':9}

4访问不存在的键时的报错
①直接访问时，键不存在就会报错

D={'a':1,'b':2,'c':3}
print(D['d'])

Traceback (most recent call last):
  File "C:\Users\Administrator\Desktop\2333333333.py", line 2, in <module>
    print(D['d'])
KeyError: 'd'

②用in判断方法

D={'a':1,'b':2,'c':3}
print('d' in D)
if not 'd' in D:
print('missing')

False
Missing

③用get方法判断，get方法中的第2个参数指键不存在时指定返回的默认值，不设置这个值，则返回None

D={'a':1,'b':2,'c':3}
print(D.get('d',0))

0

5获取字典里的键、值
获取包含所有键的列表
#D.keys方法返回的是一个迭代器，而不是直接给出一个列表。将迭代器作为参数来初始化一个list，可以一次性生成所有的键，并将他们打印出来。△

D={'a':11,'b':22,'c':33}
print(list(D.keys()))

['c','a','b']

获取值的列表

D={'a':11,'b':22,'c':33}
print(list(D.values()))

[11,33,22]

获取键值对的列表

D={'a':11,'b':22,'c':33}
print(list(D.items()))

[('b':22),('c':33),('a':11)]

6字典的删除和排序
删除使用也del和pop
del方法

D={'a':11,'b':22,'c':33}
del D['a']
print(D)

[‘b’:22,‘c’:33]
pop方法，删除指定键对应的元素，并且返回这个键所对应的值

D={'a':11,'b':22,'c':33}
print(D.pop('a'))
print(D)

11
['b':22,'c':33]

字典里的对象是无序的，但是可以对键进行排序，返回一个排好序的键的列表

D={'a':11,'b':22,'c':33}
print(sorted(D))   #内置函数sorted接受的都是可迭代对象△
print(sorted(D.keys()))

['a','b','c']
['a','b','c']

元组

元组可看做是不可变的列表

T=(1,2,3,4)
M=('spam',3.5,[11,22,33])
print(T[1])
print(M[2][0])  #第3个元素的第一个元素

2
11

○一次性获取元组中所有的项

a,b=(1,2)
print('a={},b={}.'format(a,b))

a=1,b=2

○与其他元组进行连接

T1=(1,2,3,4)
T2=(5,6,7,8)
print(T1+T2)

(1,2,3,4,5,6,7,8)

○元组的排序
#元组具有不可变性，虽然有利于保持数据的完整性，但不能就地排序。其他基于位置偏移的操作如索引和分片，元组和列表的用法相同。

要对元组排序
①将元组先转化为列表，就地排序后再转化为元组

T=('cc','bb','dd','aa')
tmp=list(T)
tmp.sort()
T=tuple(tmp)
print(T)

('aa','bb','cc','dd')

②用内置sorted方法，传入一个元祖，返回一个已经排好序的list序列

T=('cc','bb','dd','aa')
print(sorted(T))

['aa','bb','cc','dd']

Day1的【作业】

1.L = [[‘Apple’,‘Banana’,‘Pear’],[‘Java’,‘Python’,‘Ruby’],[‘Amy’,‘Baby’,‘Lisa’]
请分别打印出Apple, Python, Lisa

答：

L = [['Apple','Banana','Pear'],['Java','Python','Ruby'],['Amy','Baby','Lisa']
print(L[0][0],[1][2],[2][3])

['Apple', 'Python', 'Lisa']

2.有字典dic = {“k1”:“v1”,“k2”:“v2”,“k3”:“v3”},实现以下功能:
(1)遍历字典dic中所有的key；
(2)遍历字典dic中所有的value；
(3)循环遍历字典dic中所有的key和value；
(4)添加个键值对"k4",v4",输出添加后的字典dic；
(5)删除字典dic中的键值对"k1",“v1”,并输出删除后的字典dic;
(6)有字典dic2 = {“k1”:“v111”,“a”:“b”}通过一行操作使dic2 = {“k1”:“v111”,“k2”:“v2”,“k3”:“v3”,“k4”:“v4”,“a”:“b”}

答：
(1)

dic = {"k1":"v1","k2":"v2","k3":"v3"}
print(list(dic.keys()))

["k1","k2","k3"]

(2)

dic = {"k1":"v1","k2":"v2","k3":"v3"}
print(list(dic.values()))

["v1","v2","v3"]

(3)

dic = {"k1":"v1","k2":"v2","k3":"v3"}
print(list(dic.items()))
    
["k1":"v1","k2":"v2","k3":"v3"]

(4)

dic = {"k1":"v1","k2":"v2","k3":"v3"}
D["k4"]="v4"
print(dic)

["k1":"v1","k2":"v2","k3":"v3","k4":"v4"]

(5)

dic = {"k1":"v1","k2":"v2","k3":"v3"}
del dic["k1"]
print(dic)

["k2":"v2","k3":"v3"]

(6)

dic2 = {"k1":"v111","a":"b"}
dic={"k1":"v111","k2":"v2","k3":"v3","k4":"v4","a":"b"}
dic2.update(dic)
print(dic2)

{"k1":"v111","k2":"v2","k3":"v3","k4":"v4","a":"b"}

#怎么用一行命令，update可以吗？

3.去除列表中的重复元素，L=[‘b’, ‘c’, ‘d’, ‘c’, ‘b’, ‘a’, ‘a’]
答：使用内置函数set。还有其他方法待探索，if寻找似乎可以

L=['b', 'c', 'd', 'c', 'b', 'a', 'a']
list(set(L))
print(L)

['d','c','a','b']

4.合并有序列表（尾递归），L1=[1,3,5,7,9]，L2=[2,4,6,8]
答：

L1=[1,3,5,7,9]
L2=[2,4,6,8]
L1.extend[2,4,6,8])
L1.sort()
print(L1)

[1,2,3,4,5,6,7,8,9]