列表(list)介绍
<1>列表的格式
变量namesList 的类型为列表
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
Python比C语言的数组强大的地方在于列表中的元素可以是不同类型的
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
以后只要涉及到等号（=）的都是引用