Python 基础知识之列表、元组、字典

列表介绍

1.打印列表：

1.打印列表

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
#xiaoWang
#xiaoZhang
#xiaoHua

#2.使用for循环输出列表

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    for name in namesList:
        print(name)
    #xiaoWang
    #xiaoZhang
    #xiaoHua

#使用while循环输出列表

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    length = len(namesList)
    i = 0
    while i<length:
        print(namesList[i])
        i+=1
    #xiaoWang
    #xiaoZhang
    #xiaoHua

2.列表的相关操作

（1）添加元素（“增”append，extend，insert）
Append ：向列表添加元素
#定义变量A，默认有3个元素

    A = ['xiaoWang','xiaoZhang','xiaoHua']
    print("-----添加之前，列表A的数据-----")
    for tempName in A:
    print(tempName)
    #xiaoWang
    #xiaoZhang
    #xiaoHua

#提示、并添加元素
```python
    temp = input('请输入要添加的学生姓名:')
    A.append(temp)
    print("-----添加之后，列表A的数据-----")
    for tempName in A:
    print(tempName)
    #xiaoWang
    #xiaoZhang
    #xiaoHua
    #xixi

Extend 可以将另一个集合中的元素逐一加到列表中

a = [1, 2]
b = [3, 4]
a.append(b)
>>>a  #Out[11]: [1, 2, [3, 4]]
a.extend(b)
>>>a  #Out[13]: [1, 2, [3, 4], 3, 4]

Insert（index，object）在指定位置index前插入元素object

a = [0, 1, 2]
a.insert(1, 3)
>>>a  #Out[15]: [0, 3, 1, 2]

（2）修改元素（“改”）
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
#定义变量A，默认有3个元素

    A = ['xiaoWang','xiaoZhang','xiaoHua']
    print("-----修改之前，列表A的数据-----")
    for tempName in A:
        print(tempName)

#修改元素

    A[1]='xiaolu'
    print("-----修改之后，列表A的数据-----")
    for tempName in A:
    print(tempName)

（3）查找元素（“查”in，not in，index，count）查找指定元素是否存在
In，not in
In（存在），如果存在那么结果为true，否则为false
Not in（不存在），如果不存在那么结果为true，否则false

    #待查找的列表
    nameList = ['xiaoWang','xiaoZhang','xiaoHua']
    #获取用户要查找的名字
    findName = input('请输入要查找的姓名:')
    #查找是否存在
    if findName in nameList:
        print('在字典中找到了相同的名字')
    else:
    print('没有找到')
    Index和count与字符串中的用法相同
    a = ['a', 'b', 'c', 'a', 'b']
    a.index('a', 1, 3) # 注意是左闭右开区间，ValueError: 'a' is not in list
    a.index('a', 1, 4)#Out[3]: 3
    a.count('b')#Out[4]: 2

（4）删除元素（“删除”del,pop,remove）
Del:根据下标进行删除
Pop：删除最后一个元素
Remove：根据元素的值进行删除
Del：

    movieName = ['a','b','c','d','e']
    print('------删除之前------')
    for tempName in movieName:
        print(tempName)
    del movieName[2]
    print('------删除之后------')
    for tempName in movieName:
    print(tempName)
    ------删除之前------
    a
    b
    c
    d
    e
    ------删除之后------
    a
    b
    d
    e

    movieName.pop()
    print('------pop删除之后------')
    for tempName in movieName:
    print(tempName)
    ------pop删除之后------
    a
    b
    c
    d
    movieName.remove('b')
    print('------remove删除之后------')
    for tempName in movieName:
        print(tempName)
    ------remove删除之后------
    a
    c
    d
    e

(5)排序（sort，reverse）
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒叙，由大到小，reverse方法是将list逆序。

    a = [1, 4, 2, 3]
    a  #Out[14]: [1, 4, 2, 3]
    a.reverse()
    a  #Out[15]: [3, 2, 4, 1]
    a.sort()
    a  #Out[16]: [1, 2, 3, 4]
    a.sort(reverse=True)
    a  #Out[17]: [4, 3, 2, 1]

3.列表的嵌套

1.列表嵌套
类似while循环的嵌套，一个列表中的元素又是一个列表，那么这就是列表的嵌套
schoolNames = [[‘北京大学’,‘清华大学’],[‘南开大学’,‘天津大学’,‘天津师范大学’],[‘山东大学’,‘中国海洋大学’]]
应用：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

    import random
    # 定义一个列表用来保存3个办公室
    offices = [[],[],[]]
    # 定义一个列表用来储存8位老师的名字
    names = ['A','B','C','D','E','F','G','H']
    i = 0
    for name in names:
        index = random.randint(0,2)
        offices[index].append(name)
        i = 1
    for tempNames in offices:
        print('办公室%d的人数:%d'%(i,len(tempNames)))
        i+=1
        for name in tempNames:
            print("%s"%name,end='')
        print("\n")
    print("-"*20)

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，列表使用方括号。
（1）访问元组

    aTuple[0] #Out[40]: 'et'
    aTuple[1] #Out[41]: 77
    aTuple[2] #Out[42]: 99.9

(2)元组的内置函数count，index

    a = ('a', 'b', 'c', 'a', 'b')
    a.index('a', 1, 4) #Out[44]: 3
    a.count('b') #Out[45]: 2

字典

变量info为字典类型：
info={‘name’:‘班长’, ‘id’:100, ‘sex’:‘f’, ‘address’:‘地球亚洲中国’}
说明：
字典和列表一样，也能够储存多个数据
列表中找某个元素时，是根据下标进行的，字典中找某个元素时，是根据“名字”（冒号：前面的那个值，例如上面代码中’name’、‘id’,’sex’）
字典的每个元素由2部分组成，键：值。例如’name’:’班长’，‘name’为键，‘班长’为值。

    info={'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国'}
    print(info['name']) #班长
    print(info['address']) #地球亚洲中国

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

    age = info.get('age')
    age
    type(age) #Out[52]: NoneType
    age = info.get('age', 18) 
    age #Out[54]: 18

字典的常见操作1

（1）修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

    info={'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国'}
    newId = input('请输入新的学号：')
    info['id'] = int(newId)
    print('修改之后的id为：%d'%info['id'])

请输入新的学号：123456
修改之后的id为：123456
Out[62]: {‘name’: ‘班长’, ‘id’: 123456, ‘sex’: ‘f’, ‘address’: ‘地球亚洲中国’}

（2）添加元素

    print('修改之后的id为：%d'%info['id'])
    info={'name':'班长', 'sex':'f', 'address':'地球亚洲中国'}
    newId = input('请输入新的学号：')
    info['id'] = newId
    print('添加之后的id为:%s'%info['id'])
    #请输入新的学号：123
    #添加之后的id为:123
    info # Out[75]: {'name': '班长', 'sex': 'f', 'address': '地球亚洲中国', 'id': '123'}

（3）删除元素

对字典进行删除操作，有一下几种：
del:删除指定的元素

    del info['name']
    print('删除后,%s'%info['name'])#删除后不能访问
    info
    Out[77]: {'sex': 'f', 'address': '地球亚洲中国', 'id': '123'}

del:删除整个字典

    info.clear()
    print('清空后,%s'%info)
    clear()清空整个字典
    info.clear()
    print('清空后,%s'%info)#清空后,{}

字典的常见操作2
(1)len()测量字典中，键值对的个数

    info={'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国'}
    len(info)

(2)keys返回一个包含字典所有key的列表

     info.keys() #Out[82]: dict_keys(['name', 'id', 'sex', 'address'])

(3)values返回一个包含字典所有value的列表

    info.values() #Out[83]: dict_values(['班长', 100, 'f', '地球亚洲中国'])

(4)items返回一个包含所有（键，值）元组的列表

    info.items() #('id', 100), ('sex', 'f'), ('address', '地球亚洲中国')])
    for temp in info.items():
         print(“key=%s,value=%s”%(temp[0],temp[1]))
    key=name,value=班长
    key=id,value=100
    key=sex,value=f
    key=address,value=地球亚洲中国

(5)has_key dict.has_key(key)如果key在字典中，返回true，否则返回false
has_key方法在python2中是可以使用的，在python3中删除了。

遍历：
通过for…in…:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构
注意Python语法的缩进

    a_str = "hello itcast"
    for char in a_str:
    print(char,end=' ')
    h e l l o   i t c a s t 

列表遍历

    a_list = [1, 2, 3, 4, 5]
    for num in a_list:
        print(num,end=' ')
        
    1 2 3 4 5 

元组遍历

    a_turple = (1, 2, 3, 4, 5)
    for num in a_turple:
        print(num,end=" ")
    1 2 3 4 5 

实现带下标索引的遍历：

    chars = ['a', 'b', 'c', 'd']
    i = 0
    for chr in chars:
        print("%d %s"%(i, chr))
    i += 1
    0 a
    1 b
    2 c
    3 d

实现带下标索引的遍历：enumerate（）

  list(enumerate(seq))
  Out[99]: [(0, 'one'), (1, 'two'), (2, 'three')
 >>> "hello " + "itcast" 
        'hello itcast'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')
>>> 'ab'*4
'ababab'
>>> [1, 2]*4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b')*4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
In
>>> 'itc' in 'hello itcast'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"Delron", "age":24}
True

注意：in在对字典操作时，判断的是字典的键
Python内置函数：
cmp在比较字典数据时，先比较键，再比较值

>>> cmp([1, 2], [1, 2, 3])
-1
>>> cmp({"a":1}, {"b":1})
-1
>>> cmp({"a":2}, {"a":1})
1
>>> cmp({"a":2}, {"a":2, "b":1})
-1

len:在操作字典数据时，返回的是键值对个数

>>> len("hello itcast")
12
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({"a":1, "b":2})
2

max
>>> max("hello itcast")
't'
>>> max([1,4,522,3,4])
522
>>> max({"a":1, "b":2})
'b'
>>> max({"a":10, "b":2})
'b'
>>> max({"c":10, "b":2})
'c'

del 有两种用法，一种是del加空格，另一种是del（）

>>> a = 1
>>> a
1
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a = ['a', 'b']
>>> del a[0]
>>> a
['b']
>>> del(a)
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

多维列表/元组访问的示例

>>> tuple1 = [(2,3),(4,5)]
>>> tuple1[0]
(2, 3)
>>> tuple1[0][0]
2
>>> tuple1[0][2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> tuple1[0][1]
3
>>> tuple1[2][2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> tuple2 = tuple1+[(3)]
>>> tuple2
[(2, 3), (4, 5), 3]
>>> tuple2[2]
3
>>> tuple2[2][0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable

可变类型与不可变类型
可变类型，值可以改变：
列表 list
字典 dict
不可变类型，值不可以改变：
数值类型 int，long，bool，float
字符串 str
元组tuple