Python自学笔记(四):python中的列表,元组,字典及相关操作

列表(list)介绍

<1>列表的格式

变量namesList 的类型为列表

  namesList = ['xiaoWang','xiaoZhang','xiaoHua']

PythonC语言的数组强大的地方在于列表中的元素可以是不同类型的

    testList = [1,'a']

<2>打印列表

demo

  namesList = ['xiaoWang','xiaoZhang','xiaoHua']

    print(namesList[0])

    print(namesList[1])

    print(namesList[2])

结果:

     xiaoWang

    xiaoZhang

    xiaoHua

 

列表的循环遍历

1. 使用for循环

为了更有效率的输出列表的每个数据,可以使用循环来完成

demo:

     namesList = ['xiaoWang','xiaoZhang','xiaoHua']

    for namein namesList:

        print(name)

结果:

    xiaoWang

    xiaoZhang

    xiaoHua

2. 使用while循环

为了更有效率的输出列表的每个数据,可以使用循环来完成

demo:

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']

    length =len(namesList)

    i = 0

    while i<length:

        print(namesList[i])

        i+=1

结果:

     xiaoWang

    xiaoZhang

    xiaoHua

列表的相关操作

列表中存放的数据是可以进行修改的,比如"增"、"删"、"改""

1.添加元素("增"append, extend, insert)

append可以向列表添加元素

通过append可以向列表添加元素

   #定义变量nameList ,默认有3个元素

nameList = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前,列表A的数据-----")
for temp in nameList:
    print(temp)
newName = input("请输入要添加的姓名:")
nameList.append(newName)
print("-----添加之后,列表A的数据-----")
for tempName in nameList :
 

    print(temp)

结果:

 

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

通过extend可以将另一个集合中的元素逐一添加到列表中

append和extend的区别


insert在指定位置index前插入元素

insert(index, object) 在指定位置index前插入元素object

>>> a = [0,1,2]

>>> a.insert(1,3)  #就是在下标为1的元素前插入新元素‘3’

>>> a

[0,3,1,2]  

注意只能插入元素

append的注意事项

append()方法是没有返回值的

2.删除元素("删"del, pop, remove)

类比现实生活中,如果某位同学调班了,那么就应该把这个条走后的学生的姓名删除掉;在开发中经常会用到删除这种功能。

列表元素的常用删除方法有:

del根据下标进行删除

   movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']

    print('------删除之前------')

    for tempNamein movieName:

        print(tempName)

    del movieName[2]

    print('------删除之后------')

    for tempNamein movieName:

        print(tempName)

结果:


pop删除最后一个元素

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']

    print('------删除之前------')

    for tempNamein movieName:

        print(tempName)

    movieName.pop()

    print('------删除之后------')

    for tempNamein movieName:

        print(tempName)

结果:


remove根据元素的值进行删除

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']

    print('------删除之前------')

    for tempNamein movieName:

        print(tempName)

    movieName.remove('指环王')

    print('------删除之后------')

    for tempNamein movieName:

        print(tempName)

结果:


3.修改元素("改")

修改元素的时候,要通过下标来确定要修改的是哪个元素,然后才能进行修改

Demo:

    #定义变量movieName,默认有3个元素

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']

    print("-----修改之前,列表A的数据-----")

    for tempNamein movieName :

        print(tempName)

    #修改元素

   movieName [1] = '修改的电影名'

    print("-----修改之后,列表A的数据-----")

    for tempNamein movieName :

        print(tempName)

结果:


4.查找元素("查"in, not in, index, count)

所谓的查找,就是看看指定的元素是否存在

in, not in

python中查找的常用方法为:

  in(存在),如果存在那么结果为true,否则为false

  not in(不存在),如果不存在那么结果为true,否则false

demo

  #待查找的列表

  movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人']

    #获取用户要查找的名字

    findName = input('请输入要查找的电影:')

    #查找是否存在

    if findNamein movieName :

        print('已找到电影')

    else:

        print('没有找到')


说明:

in的方法只要会用了,那么not in也是同样的用法,只不过not in判断的是不存在

index, count

index和count与字符串中的用法大致相同

可以看出,在index()方法中,所查元素不在列表中,会返回异常

在count()中只能传一个参数,

5.排序(sort, reverse)

sort方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。

reverse方法是将list逆置。

demo

列表的嵌套

1.列表嵌套

类似while循环的嵌套,列表也是支持嵌套的

一个列表中的元素又是一个列表,那么这就是列表的嵌套

    schoolNames = [['北京大学','清华大学'],

                    ['南开大学','天津大学','天津师范大学'],

                    ['山东大学','中国海洋大学']]

2. 应用

一个学校,有3个办公室,现在有8位老师等待工位的分配,请编写程序,完成随机的分配

参考代码:

#encoding=utf-8

import random

# 定义一个列表用来保存3个办公室

offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字

names = ['A','B','C','D','E','F','G','H']

 

for namein names:

    index = random.randint(0,2)    

    offices[index].append(name)


i = 1

for tempNamesin offices:

    print('办公室%d的人数为:%d'%(i,len(tempNames)))

    i+=1

    for namein tempNames:

        print("%s"%name,end='')

    print("\n")

    print("-"*20)

运行结果如下:


元组(tuple)

Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。

<1>访问元组

>>> aTuple = ('阿布',11,99.9)

>>> aTuple

('阿布',11,99.9)

<2>修改元组

说明:python中不允许修改元组的数据,包括不能删除其中的元素。

<3>元组的内置函数count, index

index和count与列表中的用法相同

>>> a = ('a','b','c','a','b')

>>> a.index('a',1,3)# 注意是左闭右开区间

Traceback (most recent call last):

  File "<stdin>", line1,in <module>

ValueError: tuple.index(x): xnot in tuple

>>> a.index('a',1,4)

3

>>> a.count('b')

2

>>> a.count('d')

0

字典(dict)介绍

变量info为字典类型:

    info = {'name':'班长','id':100,'sex':'','address':'地球亚洲中国北京'}

说明:

字典和列表一样,也能够存储多个数据

列表中找某个元素时,是根据下标进行的

字典中找某个元素时,是根据'名字'(就是冒号:前面的那个值,例如上面代码中的'name'、'id'、'sex')

字典的每个元素由2部分组成,:值。例如 'name':'班长' ,'name'为键,'班长'为值

根据键访问值

info = {'name':'李大大 ',‘id':100,'sex':'','address':'中国北京'}

print(info['name'])

print(info['address']) 

结果:

 李大大

   中国北京

若访问不存在的键,则会报错:

>>> info['age']

Traceback (most recent call last):

  File "<stdin>", line1,in <module>

KeyError:'age'

使用get(“key”)不存在不会报错,而且可以设置默认值

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

>>> age = info.get('age')

>>> age #'age'键不存在,所以age为None

>>> type(age)

<type 'NoneType'

>>>>age = info.get('age',18)# 若info中不存在'age'这个键,就返回默认值18

>>> age

18

字典的常见操作1

1.添加元素

demo:访问不存在的元素

    info = {'name':'班长','sex':'f','address':'地球亚洲中国北京'}

    print('id为:%d'%info['id'])

结果:

如果在使用 变量名['键'] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素

demo:添加新的元素

   info = {"name":"XiaoMing","sex":"男","address":"中国北京"}

    # print('id为:%d'%info['id'])#程序会终端运行,因为访问了不存在的键

    newId = input('请输入学号')

    info['id'] = newId

    print('添加之后的id为:%d'%info['id'])

结果:


2.删除元素del

对字典进行删除操作,有以下几种:

del删除指定的元素

    info = {"name":"XiaoMing","sex":"男","address":"中国北京"}

    print('删除前,%s'%info['name'])

    del info['name']

    #print('删除后,%s'%info['name']) #删除后name的值为none,程序会报错,所以这里用get获取比较好

       print('删除后,%s'%info.get('name'))

 运行结果:


del删除整个字典

   info = {"name":"XiaoMing","sex":"男","address":"中国北京"}

    print('删除前,%s'%info)

    del info

    print('删除后,%s'%info)

 

clear清空整个字典

    info = {"name":"XiaoMing","sex":"男","address":"中国北京"}

    print('清空前,%s'%info)

    info.clear()

    print('清空后,%s'%info)

 

可以看出,用clear() 清空整个字典是,只是把字典中的内容清空,字典在内存里的存储并不会被删除,因此程序并不会出错,

3.修改元素

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

demo:

    info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}

    print(info)

    newId = input('请输入新的学号')

    info['id'] = int(newId)

    print('修改之后的id为%d:'%info['id'])

    print(info)

 运行结果:


4.查找元素

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}

print(info)
str = input('请输入要查询的内容')
print('查询结果为%s:'%info[str])

 运行结果:


同样使用info.get(key)也可以查询

字典的常见操作2

<1>len()

测量字典中,键值对的个数

 

<2>keys

返回一个包含字典所有KEY的列表


<3>values

返回一个包含字典所有value的列表

 

<4>items

返回一个包含所有(键,值)元祖的列表

 

<5>has_key

Python3中废弃了

dict.has_key(key)如果key在字典中,返回True,否则返回False

字典遍历

通过for ... in ...:的语法结构,我们可以遍历字符串、列表、元组、字典等数据结构。

注意python语法的缩进

字符串遍历

>>> a_str = "helloatguigu"

>>> for charin a_str:...    

print(char,end=' ')

h e l l o   a t g u i g u

列表遍历

>>> a_list = [1,2,3,4,5]

>>> for numin a_list:...    

print(num,end=' ')

...1 2 3 4 5

元组遍历

>>> a_turple = (1,2,3,4,5)

>>> for numin a_turple:...    

print(num,end=" ")

1 2 3 4 5

字典遍历

<1> 遍历字典的key(键)

使用keys()方法

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}
print(info)
for key in info.keys() :

    print(key)

运行结果:


<2> 遍历字典的value(值)

使用values()方法

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}
print(info)
for value in info.values() :

    print(value )


<3> 遍历字典的项(元素)

 使用items()方法

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}
print(info)
for item in info.items() :

    print(item)


<4> 遍历字典的key-value(键值对)

第一种方法:

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}
print(info)
for key,value in info.items() :
    print("key = %s,value = %s "%(key,value))

第二种方法:

info = {"name":"XiaoMing","sex":"男","address":"中国北京","sid":"110"}
print(info)
for item in info.items() :

    print("key = %s,value = %s "%(item[0],item[1]))

运行结果:


<5>实现列表带下标索引的遍历

>>> chars = ['a','b','c','d']

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

<6>使用枚举遍历enumerate()

ˈnju:məreɪt]

>>> chars = ['a','b','c','d']
>>> for i,chr in enumerate(chars):
...     print (i,chr)
... 
0 a
1 b
2 c
3 d

公共方法

运算符

运算符

Python 表达式

结果

描述

支持的数据类型

+

[1, 2] + [3, 4]

[1, 2, 3, 4]

合并

字符串、列表、元组

*

'Hi!' * 3

['Hi!', 'Hi!', 'Hi!']

复制

字符串、列表、元组

in

3 in (1, 2, 3)

True

元素是否存在

字符串、列表、元组、字典

not in

4 not in (1, 2, 3)

True

元素是否不存在

字符串、列表、元组、字典

+

>>> [1,2] + [3,4]

[1,2,3,4]

>>> ('a','b') + ('c','d')

('a','b','c','d')

*

>>> 'a'*4

aaaa

>>> [1,2]*4

[1,2,1,2,1,2,1,2]

>>> ('a','b')*4

('a','b','a','b','a','b','a','b')

in

>>> 'Python' in 'helloPython'

True

>>> 3 in [1,2]

False

>>> 4 in (1,2,3,4)

True

>>> "name" in {"name":"Delron","age":24}

True

not in 的结果与in的相反

注意,in在对字典操作时,判断的是字典的键

python内置函数

Python包含了以下内置函数

序号

方法

描述

1

cmp(item1, item2)

比较两个值(Python3中已弃用)

2

len(item)

计算容器中元素个数

3

max(item)

返回容器中元素最大值

4

min(item)

返回容器中元素最小值

5

del(item)

删除变量

len

>>> len("hello Python")

12

>>> len([1,2,3,4])

4

>>> len((1,2))

2

>>> len({"a":1,"b":2})

2

注意:len在操作字典数据时,返回的是键值对个数。

max

>>> max("hello Python")

'y'

>>> 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加空格,另一种是del()

>>>

a = 1

>>> a

1

>>>

 del a

>>> a

Traceback (most recent call last):

  File "<stdin>", line1,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>", line1,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>", line1,in <module>

IndexError: tuple index out of range   #越界异常

>>> tuple1[0][1]

3

>>> tuple2 = tuple1+[(3)]

>>> tuple2

[(2,3), (4,5),3]

>>> tuple2[2]

3

>>> tuple2[2][0]

Traceback (most recent call last):

  File "<stdin>", line1,in <module>

TypeError:'int' objectis not subscriptable    #因为tuple2中下标位2的元素是3,是个整数,不是元组,因此报错

引用

想一想

>>> a = 1

>>> b = a

>>> b

1

>>> a = 2

>>> a

2

请问此时b的值为多少?

>>> a = [1,2]

>>> b = a

>>> b

[1,2]

>>> a.append(3)

>>> a

[1,2,3]

请问此时b的值又是多少?

引用

python中,值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为同一个值的引用 我们可以将id值理解为那块内存的地址标示。

>>> a = 1

>>> b = a

>>> id(a) 13033816

>>> id(b)   # 注意两个变量的id值相同13033816

>>> a = 2

>>> id(a)   # 注意a的id值已经变了13033792

>>> id(b)   # b的id值依旧13033816

>>> a = [1,2]

>>> b = a

>>> id(a)139935018544808

>>> id(b)139935018544808

>>> a.append(3)

>>> a

[1,2,3]

>>> id(a)139935018544808

>>> id(b)       # 注意a与b始终指向同一个地址139935018544808

 由此可以看出,不同的数据类型,所使用引用的方式并不一样,因此,我们得出一个概念

可变类型与不可变类型

可变类型,值可以改变:

列表 list

字典 dict

不可变类型,值不可以改变:

数值类型 int, long, bool, float

字符串 str

元组 tuple

以后只要涉及到等号(=)的都是引用

阅读更多

没有更多推荐了,返回首页