Python (2) - 技术栈

1.列表

list

python的列表用起来和C++的vector很相似是数组

只不过C++的vector每个元素是一样的

但是python列表每个元素可以是不一样的

python 复制代码

# 创建空列表的两种方式
alist = []
alist = list()
print(type(alist))

# 创建带初始值的列表并打印
alist = [1, 2, 3, 4]
print(alist)

# 正向下标和负向下标访问
alist = [1, 2, 3, 4]
print(alist[3])
print(alist[-1])

但是和vector不同的是列表是可以执行切片操作

Python 切片遵循「左闭右开」（左包含，右不包含）

python 复制代码

# 1. 切片操作的基本使用
# a = [1, 2, 3, 4]
# print(a[1:3])

# 2. 使用切片的时候，省略边界.
a = [1, 2, 3, 4]
# 省略后边界，意思是从开始位置，一直取到整个列表结束.
print(a[1:])
# 省略前边界，意思是从列表的 0 号元素开始取，一直取到结束的后边界.
print(a[:2])
# 此处切片中的下标也可以写成负数.
print(a[:-1])
# 还可以把开始边界和结束边界，都省略掉！得到的还是列表自身.
print(a[:])

# 3. 带有步长的切片操作.
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[::1])
print(a[::2])
print(a[1:-1:2])

# 4. 步长的数值还可以是负数. 当步长为负数的时候, 意思是从后往前来取元素.
print(a[::-1])
print(a[::-2])

# 5. 当切片中的范围超出有效下标之后, 不会出现异常! 而是尽可能的把符合要求的元素给获取到.
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[1:100])

python 复制代码

# 1. 使用 for 循环遍历列表
alist = [1, 2, 3, 4]
for elem in alist:
    print(elem)

# 2. 使用 for + range 按下标遍历
alist = [1, 2, 3, 4]
for i in range(0, len(alist)):
    print(alist[i])

#//上面两种方法的区别是一种可以改变数组的值 一种不可以

# 3. 使用 while 循环手动控制下标遍历
alist = [1, 2, 3, 4]
i = 0
while i < len(alist):
    print(alist[i])
    i += 1

# 4. 使用 append 方法向列表末尾添加元素
alist = [1, 2, 3, 4]
alist.append('hello')
print(alist)

# 5. 使用 insert 方法向指定位置插入元素
alist = [1, 2, 3, 4]
alist.insert(1, 'hello')
print(alist)

python 复制代码

# 1. insert 插入元素（下标越界时插入到末尾）
a = [1, 2, 3, 4]
a.insert(1, 'hello')
a.insert(100, 'hello')
print(a)

# 2. in / not in 判断元素是否存在
a = [1, 2, 3, 4]
print(1 in a)
print(10 in a)
print(1 not in a)
print(10 not in a)

# 3. index 获取元素下标（不存在则报错）
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(3))
# print(a.index(10))  # 找不到不会返回-1 而是抛异常

# 4. pop 删除元素（无参删末尾，有参删指定下标）
a = [1, 2, 3, 4]
a.pop()
print(a)

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

# 5. remove 按值删除元素
a = ['aa', 'bb', 'cc', 'dd']
a.remove('cc')
print(a)

# 6. + 拼接列表（生成新列表）
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = b + a
print(c)
print(a)
print(b)

# 7. extend 拼接列表（修改原列表，返回 None）
a = [1, 2, 3, 4]
b = [5, 6, 7, 8]
c = a.extend(b)
print(a)
print(b)
print(c)

extend方法，其实是没有返回值的!！拿一个变量来接收一个没有返回值的方法的返回值

得到的旧是None

None类似于C++中的nullptr 和null

2.元组

元组和列表的核心区别在于

核心区别：列表可变（可增删改），元组不可变（创建后不能改）；

python 复制代码

# 1. 创建元组
a = ()
print(type(a))
b = tuple()
print(type(b))

# 2. 创建元组的时候，指定初始值
a = (1, 2, 3, 4)
print(a)

# 3. 元组中的元素也可以是任意类型的
a = (1, 2, 'hello', True, [])
print(a)

# 4. 通过下标来访问元组中的元素，下标也是从 0 开始，到 len - 1 结束
a = (1, 2, 3, 4)
print(a[1])
print(a[-1])
# print(a[100])  # 此行会抛出 IndexError

# 5. 通过切片来获取元组中的一个部分
a = (1, 2, 3, 4)
print(a[1:3])

# 6. 也同样可以使用 for 循环等方式来进行遍历元素
a = (1, 2, 3, 4)
for elem in a:
    print(elem)

# 7. 可以使用 in 来判定元素是否存在，使用 index 查找元素的下标
a = (1, 2, 3, 4)
print(3 in a)
print(a.index(3))

# 8. 可以使用 + 来拼接两个元组
a = (1, 2, 3)
b = (4, 5, 6)
print(a + b)

# 10. 当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的
def getPoint():
    x = 10
    y = 20
    return x, y  # 等价于 return (x, y)

x, y = getPoint()
print(type(getPoint()))  # 注意：这里打印的是函数类型，若要打印返回值类型，需调用函数：print(type(getPoint()))

这些是元组不支持的

3.字典

dict

字典和C++的unordered_map很类似

一个字典中的 key 的类型不一定都一样。

一个字典中的 value 的类型也不必都一样～

字典对于 key 是啥类型，有约束......

对于 value 是啥类型，没约束～

判断这个类型能否作为key

可以用hash这个函数判断是否可以哈希

python 复制代码

# 1. 创建字典
a = {}
print(type(a))
b = dict()
print(type(b))

# 2. 创建字典的同时设置初始值
a = {'id': 1, 'name': 'zhangsan'}
a = {
    'id': 1,
    'name': 'zhangsan',#最后一个，写不写都可
}

# 3. 使用 in 来判定某个 key 是否在字典中存在
a = {
    'id': 1,
    'name': 'zhangsan'
}
print('id' in a)
print('classId' in a)
# in 只是判定 key 是否存在，和 value 无关！
print('zhangsan' in a)
# not in 来判定 key 在字典中不存在
print('id' not in a)
print('classId' not in a)

# 4. 使用 [] 来根据 key 获取到 value
a = {
    'id': 1,
    'name': 'zhangsan',
    100: 'lisi'
}
print(a['id'])
print(a['name'])
print(a[100])
# print(a['classId'])  # 此行会抛出 KeyError

# 5. 在字典中新增元素，使用 [] 来进行
a = {
    'id': 1,
    'name': 'zhangsan'
}
# 这个操作就是往字典里插入新的键值对
a['score'] = 90
print(a)

# 6. 在字典中，根据 key 修改 value，也是使用 [] 来进行的
a['score'] = 100
print(a)

# 7. 使用 pop 方法，根据 key 来删除键值对
a.pop('name')
print(a)

# 8. 遍历字典
# for key in a:
#     print(key, a[key])

# print(a.keys())
# print(a.values())
# print(a.items())

for key, value in a.items():
    print(key, value)

keys 获取到字典中的所有 key

values 获取到字典中的所有 value

items 获取到字典中的所有键值对

这三个函数返回的结果是不同的自定义类型

4.文件

python 复制代码

# 使用 write 来实现写文件的操作
f = open('d:/Python环境/test.txt', 'w')
f.write('hello')
f.close()

# 写文件的时候，需要使用 w 的方式打开。如果是 r 方式打开，则会抛出异常。
# f = open('d:/Python环境/test.txt', 'r')
# f.write('world')
# f.close()

# 1. 使用 read 来读取文件内容。指定读几个字符。
f = open('d:/Python环境/test.txt', 'r', encoding='utf8')
result = f.read(2)
print(result)
f.close()

# 2. 更常见的需求，是按行来读取~~
#    最简单的办法，直接 for 循环。
f = open('d:/Python环境/test.txt', 'r', encoding='utf8')
for line in f:
    print(f'line = {line}', end='')
f.close()

# 3. 还可以使用 readlines 方法直接把整个文件所有内容都读出来，按照行组织到一个列表里。
f = open('d:/Python环境/test.txt', 'r', encoding='utf8')
lines = f.readlines()
print(lines)
f.close()

要注意一点我们要关注我们读的时候以什么encoding方式读取要和文件的一致

Python 有一个重要的机制，垃圾回收机制 (GC)，自动的把不使用的变量，给进行释放～

虽然 Python 给了我们一个后手，让我们一定程度的避免上述问题，但是也不能完全依赖，自动释放机制～～因为自动释放不一定及时

上下文管理器起到的效果：

当 with 对应的代码块执行结束，就会自动执行 f 的 close() 方法，无需手动调用。

类似C++的智能指针

5.IO

python 复制代码

input(prompt=None)
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

prompt：可选参数，是显示在控制台的提示文字，告诉用户该输入什么；

返回值：字符串（str 类型）。

*objects：要输出的一个或多个内容（可以是任意类型：字符串、数字、列表、字典等）；

sep：多个内容之间的分隔符，默认是空格；

end：输出结束后添加的字符，默认是换行符 \n（所以每次 print 都会换行）；

其他参数（file/flush）：新手暂时不用关注，主要用于输出到文件等进阶场景。

看起来可能有点麻烦但是用起来真的很简单

此外

f-string 的本质是「格式化字符串字面量」，f 是一个修饰符，只能作用在被引号包裹的字符串上。如果没有引号，Python 无法识别这是字符串，会直接报语法错误：

语法：在字符串的引号前加 f 或 F，然后用 {} 包裹变量、表达式，就能把它们嵌入到字符串里。

优势：比 % 格式化和 str.format() 更直观、性能更好，代码可读性也更高。

f-string类似C++的占位符比如%d %s等等