alist = [1, 2, 3, 4]
print(alist)

• 列表中存放的元素允许是不同的类型. (这一点和 C++ Java 差别较大).

alist = [1, 'hello', True]
print(alist)

alist = [1, 2, 3, 4]
print(alist[2])

alist = [1, 2, 3, 4]
alist[2] = 100
print(alist)

• 如果下标超出列表的有效范围, 会抛出异常.

alist = [1, 2, 3, 4]
print(alist[100])

• 因为下标是从 0 开始的, 因此下标的有效范围是 [0, 列表长度 - 1]. 使用 len 函数可以获取到列表的元素个数.

alist = [1, 2, 3, 4]
print(len(alist))

• 下标可以取负数. 表示 "倒数第几个元素"

alist = [1, 2, 3, 4]
print(alist[3])
print(alist[-1])

alist = [1, 2, 3, 4]
print(alist[1:3])

alist[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的前闭后开区间.

也就是从下标为 1 的元素开始(2), 到下标为 3 的元素结束(4), 但是不包含下标为 3 的元素.

所以最终结果只有 2, 3

alist = [1, 2, 3, 4]
print(alist[1:]) # 省略后边界, 表示获取到列表末尾
print(alist[:-1]) # 省略前边界, 表示从列表开头获取
print(alist[:]) # 省略两个边界, 表示获取到整个列表.

• 切片操作还可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步“

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::5])

• 切片操作指定的步长还可以是负数, 此时是从后往前进行取元素. 表示 "每访问一个元素之后, 下标自减几步"

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-5])

alist = [1, 2, 3, 4]
print(alist[100:200])

1.4 遍历列表元素

alist = [1, 2, 3, 4]
for elem in alist:
print(elem)

• 也可以使用 for 按照范围生成下标, 按下标访问

alist = [1, 2, 3, 4]
for i in range(0, len(alist)):
print(alist[i])

• 还可以使用 while 循环. 手动控制下标的变化

alist = [1, 2, 3, 4]
i = 0
while i < len(alist):
print(alist[i])
i += 1

1.5 新增元素

• 使用 append 方法, 向列表末尾插入一个元素(尾插).

alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)

• 使用 insert 方法, 向任意位置插入一个元素

alist = [1, 2, 3, 4]
alist.insert(1, 'hello')
print(alist)

PS: 什么是 "方法" (method)

方法其实就是函数. 只不过函数是独立存在的, 而方法往往要依附于某个 "对象".

像上述代码 alist.append , append 就是依附于 alist, 相当于是 "针对 alist 这个列表, 进行尾插操作".

alist = [1, 2, 3, 4]
print(2 in alist)
print(10 in alist)

alist = [1, 2, 3, 4]
print(alist.index(2))
print(alist.index(10))

1.7 删除元素

• 使用 pop 方法删除最末尾元素

alist = [1, 2, 3, 4]
alist.pop()
print(alist)

• pop 也能按照下标来删除元素

alist = [1, 2, 3, 4]
alist.pop(2)
print(alist)

alist = [1, 2, 3, 4]
alist.remove(2)
print(alist)

1.8 连接列表

• 使用 + 能够把两个列表拼接在一起.

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
print(alist + blist)

• 使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面.

alist = [1, 2, 3, 4]
blist = [5, 6, 7]
alist.extend(blist)
print(alist)
print(blist)

1.9 关于元组

atuple = ( )
atuple = tuple()

def getPoint():
return 10, 20
result = getPoint()
print(type(result))

a = { }
b = dict()
print(type(a))
print(type(b))

• 也可以在创建的同时指定初始值
• 键值对之间使用 , 分割, 键和值之间使用 : 分割. (冒号后面推荐加一个空格).
• 使用 print 来打印字典内容

student = { 'id': 1, 'name': 'zhangsan' }
print(student)

• 为了代码更规范美观, 在创建字典的时候往往会把多个键值对, 分成多行来书写.

student = {
'id': 1,
'name': 'zhangsan'
}

• 最后一个键值对, 后面可以写 , 也可以不写.

student = {
'id': 1,
'name': 'zhangsan',
}

2.3 查找key

• 使用 in 可以判定 key 是否在 字典 中存在. 返回布尔值.

student = {
'id': 1,
'name': 'zhangsan',
}
print('id' in student)
print('score' in student)

• 使用 [ ] 通过类似于取下标的方式, 获取到元素的值. 只不过此处的 "下标" 是 key. (可能是整数, 也可能是字符串等其他类型).

student = {
'id': 1,
'name': 'zhangsan',
}
print(student['id'])
print(student['name'])

• 如果 key 在字典中不存在, 则会抛出异常.

student = {
'id': 1,
'name': 'zhangsan',
}
print(student['score'])

2.4 新增/修改元素

student = {
'id': 1,
'name': 'zhangsan',
}
student['score'] = 90
print(student)

• 如果 key 已经存在, 对取下标操作赋值, 即为修改键值对的值.

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student['score'] = 90
print(student)

2.5 删除元素

• 使用 pop 方法根据 key 删除对应的键值对.

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
student.pop('score')
print(student)

2.6 遍历字典元素

• 直接使用 for 循环能够获取到字典中的所有的 key, 进一步的就可以取出每个值了.

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
for key in student:
print(key, student[key])

2.7 取出所有key和value

• 使用 keys 方法可以获取到字典中的所有的 key

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.keys())

此处 dict_keys 是一个特殊的类型, 专门用来表示字典的所有 key. 大部分元组支持的操作对于

dict_keys 同样适用.

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.values())

此处 dict_values 也是一个特殊的类型, 和 dict_keys 类似.

student = {
'id': 1,
'name': 'zhangsan',
'score': 80
}
print(student.items())

2.8 合法key类型

• 可以使用 hash 函数计算某个对象的哈希值.
• 但凡能够计算出哈希值的类型, 都可以作为字典的 key.

print(hash(0))
print(hash(3.14))
print(hash('hello'))
print(hash(True))
print(hash(())) # ( ) 是一个空的元组

• 列表无法计算哈希值.

print(hash([1, 2, 3]))

• 字典也无法计算哈希值

print(hash({ 'id': 1 }))

2.9 小结

• 文本文件 (txt)
• 可执行文件 (exe, dll)
• 图片文件 (jpg, gif)
• 视频文件 (mp4, mov)
• office 文件 (.ppt, docx)
• ......

• D: 表示 盘符. 不区分大小写.
• 每一个 \ 表示一级目录. 当前 QQ.exe 就是放在 "D 盘下的 program 目录下的 qq 目录下的 Bin 目录中" .
• 目录之间的分隔符, 可以使用 \ 也可以使用 / . 一般在编写代码的时候使用 / 更方便.

f = open('d:/test.txt', 'r')

• 第一个参数是一个字符串, 表示要打开的文件路径
• 第二个参数是一个字符串, 表示打开方式. 其中 r 表示按照读方式打开. w 表示按照写方式打开. a表示追加写方式打开.
• 如果打开文件成功, 返回一个文件对象. 后续的读写文件操作都是围绕这个文件对象展开.
• 如果打开文件失败(比如路径指定的文件不存在), 就会抛出异常.

f.close()

flist = []
count = 0
while True:
f = open('d:/test.txt', 'r')
flist.append(f)
count += 1
print(f'count = {count}')

如上面代码所示, 如果一直循环的打开文件, 而不去关闭的话, 就会出现上述报错.

当一个程序打开的文件个数超过上限, 就会抛出异常.

注意: 上述代码中, 使用一个列表来保存了所有的文件对象. 如果不进行保存, 那么 Python 内置的垃圾回收机制, 会在文件对象销毁的时候自动关闭文件.

但是由于垃圾回收操作不一定及时, 所以我们写代码仍然要考虑手动关闭, 尽量避免依赖自动关闭.

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()

用记事本打开文件, 即可看到文件修改后的内容.

f = open('d:/test.txt', 'r')
f.write('hello')
f.close()

• 使用 'w' 一旦打开文件成功, 就会清空文件原有的数据.
• 使用 'a' 实现 "追加写", 此时原有内容不变, 写入的内容会存在于之前文件内容的末尾.

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()
f = open('d:/test.txt', 'a')
f.write('world')
f.close()

• 针对已经关闭的文件对象进行写操作, 也会抛出异常.

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()
f.write('world')

3.3.4 读文件

• 读文件内容需要使用 'r' 的方式打开文件
• 使用 read 方法完成读操作. 参数表示 "读取几个字符"

f = open('d:/test.txt', 'r')
result = f.read(2)
print(result)
f.close()

f = open('d:/test.txt', 'r')
for line in f:
print(f'line = {line}')
f.close()

注意: 由于文件里每一行末尾都自带换行符, print 打印一行的时候又会默认加上一个换行符, 因此打印结果看起来之间存在空行.

使用 print(f'line = {line}', end='') 手动把 print 自带的换行符去掉.

f = open('d:/test.txt', 'r')
lines = f.readlines()
print(lines)
f.close()

3.3.5 关于中文的处理

• 如果此处的编码为 ANSI , 则表示 GBK 编码.
• 如果此处为 UTF-8 , 则表示 UTF-8 编码.

f = open('d:/test.txt', 'r', encoding='utf8')

字符编码问题, 是编程中一类比较常见, 又比较棘手的问题. 需要对于字符编码有一定的理解, 才能从容应对.

• 使用 with 语句打开文件.
• 当 with 内部的代码块执行完毕后, 就会自动调用关闭方法

with open('d:/test.txt', 'r', encoding='utf8') as f:
lines = f.readlines()
print(lines)