专业网站建设代理商,科技企业网站如何建设,网上北京网站制作公司,长沙网站运营外包公司此栏目记录我学习《流畅的Python》一书的学习笔记#xff0c;这是一个自用笔记#xff0c;所以写的比较随意
元组
元组其实是对数据的记录#xff1a;元组中的每个元素都存放了记录中一个字段的数据#xff0c;外加这个字段的位置。简单试试元组的特性#xff1a;
char…此栏目记录我学习《流畅的Python》一书的学习笔记这是一个自用笔记所以写的比较随意
元组
元组其实是对数据的记录元组中的每个元素都存放了记录中一个字段的数据外加这个字段的位置。简单试试元组的特性
chars_tuple (a, b, c, d, e, f)
# 元组拆包
a, b, c, d, e, f chars_tuple
print(a)
print(chars_tuple[0])
test_tuple ((1, 2), (3, 4))
print(test_tuple[0][1])
print(chars_tuple[1:])运行结果 还可以用*将元组拆包成函数的参数
# 用*将元组拆包作为函数的参数
number_tuple (1, 2)
print(test_fun(*number_tuple))运行结果 3 元组拆包还可以让一个函数可以用元组的形式返回多个值然后调用函数的代码就能轻松地接受这些返回值。 比如 os.path.split() 函数就会返回以路径和最后一个文件名组成的元组 (path, last_part)
import os
file os.path.split(/home/luciano/.ssh/idrsa.pub)
print(file)运行结果 (‘/home/luciano/.ssh’, ‘idrsa.pub’) 挺有意思我写个简单的例子试试
def return_a_tuple(a, b, c, d):result (a b, c d)return resultprint(return_a_tuple(1, 1, 2, 2))
运行结果 (2, 4)
函数用 *args 来获取不确定数量的参数
a, b, *rest range(5)
print(a, b, rest)
运行结果 0 1 [2, 3, 4] 在平行赋值中* 前缀只能用在一个变量名前面但是这个变量可以出现在赋值表达式的任意位置
a, *rest, b range(5)
print(a, b, rest)运行结果 0 4 [1, 2, 3]
嵌套元组拆包
用嵌套元组拆包来打印信息
Python格式化输出
在 Python 中格式化输出是通过字符串中的格式化字段来实现的。格式化字段以 { } 作为界定符其中可以包括占位符和格式化标识符。常用的格式化字符串方法包括 字符串格式化符号 ‘%’ 格式化块的语法为 “%[width][.precision]specifier”它可以用于整数、浮点数、字符串等数据类型的格式化输出。其中width 表示输出宽度precision 表示浮点数输出的小数位数specifier 表示数据类型、输出格式等。例如
name Tom
age 25
print(My name is %s, and I am %d years old. % (name, age))输出结果 My name is Tom, and I am 25 years old.
字符串的 format() 方法 可以使用 format() 方法来对字符串进行格式化输出。可以在字符串中使用占位符 {} 来表示需要替换的内容然后通过 format() 方法传入需要替换的值。例如
name Tom
age 25
print(My name is {}, and I am {} years old..format(name, age))输出结果 My name is Tom, and I am 25 years old. f-string f-string 是从 Python3.6 开始引入的一种字符串格式化方法。它的格式为 f’字符串 {变量1} {变量2}。通过在字符串前添加 ‘f’然后在花括号内添加变量的名称就可以在字符串内进行格式化输出。例如
name Tom
age 25
print(fMy name is {name}, and I am {age} years old.)输出结果 My name is Tom, and I am 25 years old. 在使用 f-string 格式化输出时可以在花括号中使用表达式等 Python 的语法。同时也可以使用限定符来控制输出格式例如
amount 1234.5678
print(f{amount:.2f}) # 输出两位小数输出结果 1234.57 模仿书中示例写一个拆包
people_info [(1, Tom, 25, (A, 1)),(2, Jack, 26, (B, 2)),(3, Mary, 39, (C, 3))]# 各个元组元素的字符串长度最大值
l1_max 0
l2_max 0
l3_max 0
l4_max 0
# 一次性找到每个元组的元素拼成字符串的最大长度
for x1, x2, x3, (x4, x5) in people_info:x1_len len(str(x1))x2_len len(x2)x3_len len(str(x3))x4_x5_len len(str(x5)) len(x4)if l1_max x1_len:l1_max x1_lenif l2_max x2_len:l2_max x2_lenif l3_max x3_len:l3_max x3_lenif l4_max x4_x5_len:l4_max x4_x5_len
# 比较表头和表中的字符串最大长度哪个大哪个大就用哪个
l1_max max(l1_max, len(ID))
l2_max max(l2_max, len(Name))
l3_max max(l3_max, len(Age))
l4_max max(l4_max, len(Address))
# 打印表头
print({:^{}s}|{:^{}s}|{:^{}s}|{:^{}s}.format(ID, l1_max, Name, l2_max, Age, l3_max, Address, l4_max))
# 嵌套元组拆包格式化输出
for x1, x2, x3, (x4, x5) in people_info:print({:^{}s}|{:^{}s}|{:^{}s}|{:^{}s}.format(str(x1), l1_max,x2, l2_max,str(x3), l3_max,x4 str(x5), l4_max))输出结果 之前的namedtuple是具名元组就是有名字的元组可以当个简单的“类”collections.namedtuple 是一个工厂函数它可以用来构建一个带字段名的元组和一个有名字的类——这个带名字的类对调试程序有很大帮助。
元组和列表的具体方法和属性区别
方法列表 是否具有元组 是否具有功能s.__add__(s2)√√s s2拼接s.__iadd__(s2)√×s s2就地拼接s.append(e)√×在尾部添加一个新元素s.clear()√×删除所有元素s.__contains__(e)√√s 是否包含 es.copy()√×列表的浅复制s.count(e)√√e 在 s 中出现的次数s.__delitem__(p)√×把位于 p 的元素删除s.extend(it)√×把可迭代对象 it 追加给 ss.__getitem__(p)√√s[p]获取下标为 p 的元素s.__getnewargs__()×√在 pickle 中支持更加优化的序列化s.index(e)√√在 s 中找到元素 e 第一次出现的位置s.insert(p, e)√×在下标 p 对应的元素之前插入元素 es.__iter__()√√获取 s 的迭代器s.__len__()√√len(s)元素的数量s.__mul__(n)√√s * nn 个 s 的重复拼接s.__imul__(n)√×s * n就地重复拼接s.__rmul__(n)√√n * s反向拼接s.pop([p])√×删除最后或者是可选的位于 p 的元素并返回它的值s.remove(e)√×删除 s 中的第一次出现的 es.reverse()√×就地把 s 的元素倒序排列s.__reversed__()√×返回 s 的倒序迭代器s.__setitem__(p, e)√×s[p] e把元素 e 放在位置 p替代已经在那个位置的元素s.sort([key], [reverse])√×就地对 s 中的元素进行排序可选的参数有键key和是否倒序reverse
试试上述操作 先从列表开始
# 列表的基本操作
import picklea [1, 2, 3]
print(a str(a))
b [4, 5, 6]
print(b str(b))
print()
# __add__拼接
print(__add__拼接)
print(ab:ab str(a b))
print()
# __iadd__就地拼接
print(__iadd__就地拼接)
print(ab:, end)
a b
print(a str(a))
print()
# append在尾部添加一个新元素
print(append在尾部添加一个新元素)
a.append(7)
print(a.append(7):a str(a))
print()
# clear删除所有元素
print(clear删除所有元素)
a.clear()
print(a.clear():a str(a))
print()
# __contaions__ 是否包含
print(__contaions__ 是否包含)
print(b str(b) , 7 in b: str(7 in b))
print(b str(b) , 6 in b: str(6 in b))
print()
# copy列表浅拷贝
print(copy列表浅拷贝)
c [0]
print(c str(c))
c b.copy()
print(cb.copy(): c str(c))
print()
# count(e)统计e在列表中出现的次数
print(count(e)统计e在列表中出现的次数)
d [1, 1, 1, 1, 2, 2, 3]
print(d str(d))
print(d.count(1): str(d.count(1)))
print()
# del(-1)删除末尾元素
print(del(-1)删除末尾元素)
print(d str(d))
del (d[-1])
print(del(a[-1]),d str(d))
print()
# extend(it)把可迭代对象it追加s
print(extend(it)把可迭代对象it追加s)
f (6, 7, 8)
print(元组f str(f))
print(列表d str(d))
d.extend(f)
print(d.extend(f):d str(d))
print()
# __getitem__获取下标为p的元素
print(__getitem__获取下标为p的元素)
print(d str(d))
print(d[6] str(d[6]))
print()
# 在 pickle 中支持更加优化的序列化
# pickle提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上。
print(在 pickle 中支持更加优化的序列化)
print(创建文件test.txt)
f open(test.txt, wb)
print(d str(d))
print(将列表b序列化为二进制对象写入文件test.txt)
# 将 python 对象转换序列化为字节二进制对象。
pickle.dump(d, f, 0)
f.close()
print(读取文件test.txt)
f open(test.txt, rb)
print(从文件test.txt中将二进制对象读取反序列化为 python 对象x)
x pickle.load(f)
f.close()
print(x str(x))
print()
# index(e)找到列表中元素e第一次出现的位置
print(index(e)找到列表中元素e第一次出现的位置)
print(d str(d))
print(d.index(2): str(d.index(2)))
print()
# insert(p,e),在下标p对应的元素插入元素e
print(insert(p,e),在下标p对应的元素插入元素e)
print(d str(d))
d.insert(2, 100)
print(d.insert(100,2),d str(d))
print()
# __iter__()获取迭代器
print(__iter__()获取迭代器)
print(d str(d))
print(遍历迭代d)
for item in d:print(item)
print()
# __len__元素的数量
print(__len__元素的数量)
print(d str(d))
print(len(d): str(len(d)))
print()
# __mul__n个元素重复拼接
print(__mul__n个元素重复拼接)
print(d str(d))
x d * 3
print(xd*3:x str(x))
print()
# __imul__就地重复拼接
print(__imul__就地重复拼接)
print(b str(b))
b * 3
print(b * 3:b str(b))
print()
# __rmul__n * s反向拼接
print(__rmul__n * s反向拼接)
f [1, 2, 3]
print(f str(f))
q 3 * f
print(q 3 * f:q str(q))
print()
# pop删除最后或者是可选的位于 p 的元素并返回它的值
print(pop删除最后或者是可选的位于 p 的元素并返回它的值)
print(f str(f))
f.pop()
print(f.pop():f str(f))
print()
# remove(e)删除第一次出现的e
print(remove(e)删除第一次出现的e)
print(q str(q))
q.remove(2)
print(q.remove(2):q str(q))
print()
# reverse就地把 s 的元素倒序排列
print(reverse就地把 s 的元素倒序排列)
print(f str(f))
f.reverse()
print(f.reverse():f str(f))
print()
# __reversed__返回 s 的倒序迭代器
print(__reversed__返回 s 的倒序迭代器)
print(q str(q))
print(倒序遍历)
for item in reversed(q):print(item)
print()
# __setitem__s[p] e把元素 e 放在位置 p替代已经在那个位置的元素
print(__setitem__s[p] e把元素 e 放在位置 p替代已经在那个位置的元素)
print(q str(q))
q[0] 100
print(q[0]100,q str(q))
print()
# sort([key], [reverse]) 就地对 s 中的元素进行排序可选的参数有键key和是否倒序reverse
print(sort([key], [reverse]) 就地对 s 中的元素进行排序可选的参数有键key和是否倒序reverse)
k [1, 0, 9, 8, 7, 2, 3, 5, 4, 6]
print(k str(k))
k.sort()
print(sort(k):k str(k))# 偶数
def key_func(a):return a % 2# 按偶数排序
k.sort(keykey_func)
print(按偶数排序)
print(k.sort(keykey_func):k str(k))# 按偶数倒着排序
k.sort(keykey_func, reverseTrue)
print(按偶数排序)
print(k.sort(keykey_func):k str(k))
运行结果 a[1, 2, 3] b[4, 5, 6]
__add__拼接 ab:ab[1, 2, 3, 4, 5, 6]
__iadd__就地拼接 ab:a[1, 2, 3, 4, 5, 6]
append在尾部添加一个新元素 a.append(7):a[1, 2, 3, 4, 5, 6, 7]
clear删除所有元素 a.clear():a[]
__contaions__ 是否包含 b[4, 5, 6], 7 in b:False b[4, 5, 6], 6 in b:True
copy列表浅拷贝 c[0] cb.copy(): c[4, 5, 6]
count(e)统计e在列表中出现的次数 d[1, 1, 1, 1, 2, 2, 3] d.count(1):4
del(-1)删除末尾元素 d[1, 1, 1, 1, 2, 2, 3] del(a[-1]),d[1, 1, 1, 1, 2, 2]
extend(it)把可迭代对象it追加s 元组f(6, 7, 8) 列表d[1, 1, 1, 1, 2, 2] d.extend(f):d[1, 1, 1, 1, 2, 2, 6, 7, 8]
__getitem__获取下标为p的元素 d[1, 1, 1, 1, 2, 2, 6, 7, 8] d[6]6
在 pickle 中支持更加优化的序列化 创建文件test.txt d[1, 1, 1, 1, 2, 2, 6, 7, 8] 将列表b序列化为二进制对象写入文件test.txt 读取文件test.txt 从文件test.txt中将二进制对象读取反序列化为 python 对象x x[1, 1, 1, 1, 2, 2, 6, 7, 8]
index(e)找到列表中元素e第一次出现的位置 d[1, 1, 1, 1, 2, 2, 6, 7, 8] d.index(2):4
insert(p,e),在下标p对应的元素插入元素e d[1, 1, 1, 1, 2, 2, 6, 7, 8] d.insert(100,2),d[1, 1, 100, 1, 1, 2, 2, 6, 7, 8]
__iter__()获取迭代器 d[1, 1, 100, 1, 1, 2, 2, 6, 7, 8] 遍历迭代d 1 1 100 1 1 2 2 6 7 8
__len__元素的数量 d[1, 1, 100, 1, 1, 2, 2, 6, 7, 8] len(d):10
__mul__n个元素重复拼接 d[1, 1, 100, 1, 1, 2, 2, 6, 7, 8] xd*3:x[1, 1, 100, 1, 1, 2, 2, 6, 7, 8, 1, 1, 100, 1, 1, 2, 2, 6, 7, 8, 1, 1, 100, 1, 1, 2, 2, 6, 7, 8]
__imul__就地重复拼接 b[4, 5, 6] b * 3:b[4, 5, 6, 4, 5, 6, 4, 5, 6]
__rmul__n * s反向拼接 f[1, 2, 3] q 3 * f:q[1, 2, 3, 1, 2, 3, 1, 2, 3]
pop删除最后或者是可选的位于 p 的元素并返回它的值 f[1, 2, 3] f.pop():f[1, 2]
remove(e)删除第一次出现的e q[1, 2, 3, 1, 2, 3, 1, 2, 3] q.remove(2):q[1, 3, 1, 2, 3, 1, 2, 3]
reverse就地把 s 的元素倒序排列 f[1, 2] f.reverse():f[2, 1]
__reversed__返回 s 的倒序迭代器 q[1, 3, 1, 2, 3, 1, 2, 3] 倒序遍历 3 2 1 3 2 1 3 1
__setitem__s[p] e把元素 e 放在位置 p替代已经在那个位置的元素 q[1, 3, 1, 2, 3, 1, 2, 3] q[0]100,q[100, 3, 1, 2, 3, 1, 2, 3]
sort([key], [reverse]) 就地对 s 中的元素进行排序可选的参数有键key和是否倒序reverse k[1, 0, 9, 8, 7, 2, 3, 5, 4, 6] sort(k):k[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 按偶数排序 k.sort(keykey_func):k[0, 2, 4, 6, 8, 1, 3, 5, 7, 9] 按偶数排序 k.sort(keykey_func):k[1, 3, 5, 7, 9, 0, 2, 4, 6, 8]
进程已结束,退出代码0
写个随笔不是写教程下面就不仔细展开了直接按我的风格测试一下元组的操作
# 元组的基本操作
import pickle# 拼接
a (1, 2, 3)
b (4, 5, 6)
print(a b)
print(0 in a b)
print((a b).count(1))
print((a b)[4])
f open(test1.txt, wb)
pickle.dump(a b, f, 0)
f.close()
f open(test1.txt, rb)
x pickle.load(f)
print(x)
print(x.index(2))
for item in x:print(item)
print(len(x))
print(x * 3)
print(3 * x)运行结果 (1, 2, 3, 4, 5, 6) False 1 5 (1, 2, 3, 4, 5, 6) 1 1 2 3 4 5 6 6 (1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6) (1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6)
进程已结束,退出代码0
切片
写几个例子试试
import numpy as npl [10, 20, 30, 40, 50, 60]
print(l[:2]) # 在下标为2处切割保留左侧
print(l[3:]) # 在下标为3处切割保留右侧
print(l[::2]) # 在整个区间以2为间隔切片
print(l[::-1]) # 在整个区间倒着以1为间隔取相当于倒序
print(l[::-2]) # 在整个区间倒着以2位间隔取
print(l[1:5:2]) # 在下标1到45是开区间中以2位间隔取
s1 slice(0, 5) # 下标切片从0到45是开区间
print(l[s1])
s2 slice(0, 5, 2) # 下标切片从0到4以2为分割取
print(l[s2])
s3 slice(0, None) # [0, 末尾)左闭右开
print(l[s3])
m [[[1, 2, 3], [4, 5, 6], [7, 8, 9]],[[10, 11, 12], [13, 14, 15], [16, 17, 18]],[[19, 20, 21], [22, 23, 24], [25, 26, 27]]]
m_array np.array(m)
print(m_array[2, ...]) # 找到下标为2的第一层维度的全部元素
print(m_array[1:2:1]) # 第一层维度下标为1到1左闭右开区间间隔为1的
print(m_array[1:2:1, 1:2:1]) # 第一层维度下标为1到1左闭右开区间间隔为1的第二层维度下标从1到2间隔为1的
print(m_array[1:2:1, 1:2:1, 0:2:2]) # 第一层维度下标为1到1左闭右开区间间隔为1的第二层维度下标从1到2间隔为1的第三层维度下标从0到1间隔为2的# 给切片赋值
print(l)
l[1:3] [3, 4]
print(l)
# 删除下标0到1
del l[0:2]
print(l)
# 从下标0开始到下标为2结束以2为间隔赋值
l[0:3:2] [100, 200]
print(l)
# 把下标从0到1的部分都换成一个元素
l[0:2] [100000]
print(l)运行结果 [10, 20] [40, 50, 60] [10, 30, 50] [60, 50, 40, 30, 20, 10] [60, 40, 20] [20, 40] [10, 20, 30, 40, 50] [10, 30, 50] [10, 20, 30, 40, 50, 60] [[19 20 21] [22 23 24] [25 26 27]] [[[10 11 12] [13 14 15] [16 17 18]]] [[[13 14 15]]] [[[13]]] [10, 20, 30, 40, 50, 60] [10, 3, 4, 40, 50, 60] [4, 40, 50, 60] [100, 40, 200, 60] [100000, 200, 60]
进程已结束,退出代码0
建立由列表组成的列表
# 一个包含 3 个列表的列表
board [[1] * 3 for i in range(3)]
print(board)
board[0][1] 0
print(board)
# 如果在 a * n 这个语句中序列 a 里的元素是对其他可变对象的引用的话
# 你就需要格外注意了因为这个式子的结果可能会出乎意料。比如你想用
# my_list [[]] * 3 来初始化一个由列表组成的列表但是你得到的列表里
# 包含的 3 个元素其实是 3 个引用而且这 3 个引用指向的都是同一个列表。
# 这可能不是你想要的效果。
weird_board [[2] * 3] * 3
print(weird_board)
weird_board[0][1] 1
print(weird_board)运行结果 [[1, 1, 1], [1, 1, 1], [1, 1, 1]] [[1, 0, 1], [1, 1, 1], [1, 1, 1]] [[2, 2, 2], [2, 2, 2], [2, 2, 2]] [[2, 1, 2], [2, 1, 2], [2, 1, 2]]
序列的增量赋值
不可变序列增量赋值会每次都生成一个新对象而可变序列则不变对象对不可变序列进行重复拼接操作的话效率会很低因为每次都有一个新对象而解释器需要把原来对象中的元素先复制到新的对象里然后再追加新的元素。用变量的ID就能看出来
l [1, 2, 3]
print(id(l))
l * 2
print(id(l))
t (1, 2, 3)
print(id(t))
t * 2
print(id(t))运行结果 2178472089152 2178472089152 2178472072896 2178469543840 元组的ID变化了 P.S 不要把可变对象放在元组里面 不可变对象中放入可变对象进行增量赋值操作最后会出错
list.sort方法和内置函数sorted
list.sort 方法会就地排序列表也就是说不会把原列表复制一份。而是内置函数 sorted它会新建一个列表作为返回值。
num1 [3, 1, 2, 6, 4, 5]
print(sorted(num1))
# 倒序排序
print(sorted(num1, reverseTrue))
fruits [grape, raspberry, apple, banana]
# 按长度排序
print(sorted(fruits, keylen))运行结果 [1, 2, 3, 4, 5, 6] [6, 5, 4, 3, 2, 1] [‘grape’, ‘apple’, ‘banana’, ‘raspberry’]
