Python学习笔记

文档中函数的参数带方括号( [ or ] )代表可选参数

列表(list)

基础

列表是可迭代对象，列表有序

矩阵

# 创建列表
[1,2,3,4,5]
# 列表可以包含不同的数据类型
[1,2,3,"hello"]
# 可以使用下表索引(从0开始)
rhyme[1]
rhyme[-1]
# 切片(不包含末尾)
rhyme[0:3]
rhyme[:3]
rhyme[3:]
rhyme[:]
rhyme[0:6:2]#跨度
rhyme[::-1]#倒序输出

方法

# 添加
rhyme.append('1')#一次只能添加一个
rhyme.extend(['1','2','3'])#添加一个可迭代对象

s[len(s):] = [6]#通过切片添加
s[len(s):] = [6,7,8,9]

# 插入
s = [1,3,4,5]
s.insert(1,2)#在指定下标插入元素([1,2,3,4,5])

# 删除
rhyme.remove('1')#如果列表中存在多个匹配元素则只会删除第一个，若指定的元素不存在则会报错
rhyme.pop(1)#删除指定下标位置的元素
rhyme.clear()#清空

# 修改
rhyme[1] = '1'
rhyme[3:] = ['1','2','3']

# 排序
num = [3,1,9,6,8,3,5,3]
num.sort()#list的方法，属于列表的成员方法，对list本身修改
sorted(num)#可以对所有可迭代对象使用，返回一个新的list

num.reverse()#反转

# 查找
num.count(3)#查找num中3的数量
num.index(2)#查找num中元素2的下标，若有多个值则返回第一个
num.index(x,bigen,end)#bigen,end查找的开始和结束位置(不包含末尾)

num[num.index(2)] = 6#在不知道元素位置的情况下修改它

# 拷贝
num_copy = num.copy()#都是浅拷贝
num_copy2 = num[:]

运算

s = [1,2,3]
t = [4,5,6]
s + t#[1,2,3,4,5,6]

# 嵌套列表
m = [[1,2,3],[4,5,6],[7,8,9]]
# 访问嵌套列表
for i in m:
    for j in i:
        print(j,end = ' ')
    print()
    
m[0][0] = 1
# 通过循环创建列表
for i in range(3):
    m[i] = [0] * 3

浅拷贝和深拷贝

注意在python中变量不是一个盒子，应该是一个引用

x = [1,2,3]
y = x
x[1] = 0
#y = [1,0,3]

#浅拷贝(浅拷贝只是拷贝了外层对象，内层还是引用)
y = x.copy()
y = x[:]

x = [[1,2,3],[4,5,6],[7,8,9]]
y = x.copy()
y[1][1] = 0
#x = [[1,2,3],[4,0,6],[7,8,9]]

#深拷贝(模块)
import copy
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.copy(x) #模块的浅拷贝
y = copy.deepcopy(x) #模块的深拷贝(将子对象也进行拷贝)

列表推导式(效率高)

[expression for target in itaerable]

我的感觉是把每一次的expression给封装起来作为列表的一个元素

# 每个数乘2
res = [i * 2 for i in res]

#字符乘2
res = [c * 2 for c in "FishC"]
['FF', 'ii', 'ss', 'hh', 'CC']

#字符ascii编码
res = [ord(c) for c in "FishC"]
[70, 105, 115, 104, 67]

#二维列表
s = [[0] * 3 for i in range(3)]

#加入判断 (条件判断比表达式等级高,实际上从第一个for开始向右运行，表达式最后)
[i for i in range(10) if i % 2 == 0]
[w for w in words if w[0] == 'a']
f = [col for row in a for col in row]
 [[x, y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]

元组

基础

元组与列表相似，就是不能修改

是可迭代对象，有序

元组的关键是,，没有圆括号也可以生成元组

res = (1, 2, 3, 4, 5, "abc")

方法

元组不能修改所以只能“查”

res = (1, 2, 3, 4, 5, 6)
res.count(3)

res.index(3)

#拼接
s = (1, 2, 3)
t = (4, 5, 6)
s + t
(1, 2, 3, 4, 5, 6)

打包与解包

# 打包
t = (123, "abc", 3.14)

#解包
x, y, z = t
a, b, c = "abc"

其他

#设置只有一个元素的元组
s = (520,)

#用元组存储可变元素
s = ([1, 2, 3], [4, 5, 6])

字符串

基础

字符串是一个序列，一个像元组那样不可变的序列

方法

因为字符串是不可变的所以字符串的所有方法都是返回一个新的字符

None在字符串中指定为空格

#切片
x = '12345'
x[::-1]
'54321'

'''
大小写字母转换
'''
##将所有大写字母转化为小写字母(可以处理其他语言)
x.casefold()

##将所有单词开头转化为大写字母，其他部分转化为小写字母
x.title()

##将所有大小写字母翻转
x.swapcase()

##将所有字母转换为大写(只能处理英文)
x.upper()

##将所有字母转换为小写(只能处理英文)
x.lower()

'''
对齐方式(依靠width参数，若width比原字符串小则直接输出原字符串)
'''
##居中对齐
x.center(width,"")

##左对齐
x.ljust(width,"")

##右对齐
x.rjust(width,"")

##用0填充左侧(数字的符号会移动到最左边)
x.zfill(width)

'''
查找
'''
x.count("a",start, end) #字符串中a出现的次数

#查找子字符串在字符串中出现的索引下标值（若找不到则返回-1）
x.find("a") #从左往右
x.rfind("a") #从右往左

x.index("a") #与find相似，但是在找不到的情况下是报错
x.rindex("a")

'''
替换
'''
#将tab替换成空格
new_code = code.expandtabs(4)

#将old指定的子字符串替换成new指定的子字符串
replace(old, new, count = -1)

#根据table参数转换
table = str.maketrans("ABCDEFG", "1234567")
"I love FishC".translate(table)

'''
判断(返回的都是布尔类型的值)
'''
#判断参数指定的子字符串是否出现在指定字符串的起始位置
x = "abcdef"
x.startswith("a") # true

#判断参数指定的子字符串是否出现在指定字符串的末尾位置
x.endswit("ef")

if x.startswith(("a", "b", "c")): # 支持将元组做为多个参数传入

#判断单词是否都已大写字母开头
x.istitle()

#判断字符串中所有的字母是否都是大写字母
x.isupper()

#判断字符串中所有的字母是否都是小写字母
x.islower()

#判断字符串是否只以字母构成 (空格，tab等也不是字母)
x.isalpha()

#判断是否为空白字符串（空格，tab，转义字符）
x.isalpha()

#判断是否所有字符都是可以打印的(转义字符不能打印)
x.isprintable()

#判断是否为数字（集大成者）
x.isalnum()

'''
移除空白
'''
#chars:去除的子字符串（按照单个字符为单位剔除），默认为None
"www.bing.com".listrip("wcom.")
"bing.com"

#移除左侧空格
"   a".lstrip(chars)

#移除右侧空格
"a   ".rstrip(chars)

#移除两侧空格
"   a   ".strip(chars)

#删除具体的子字符串
x.removeprefix(str) # 左
x.removesuffix(str) # 右

'''
拆分&拼接 
'''
#拆分成三元组
"www.bing.com".partition(".")
('www', '.', 'bing.com')

x.partition(str) # 左
x.rpartition(str) # 右

#通过分隔符分割(返回分割后的列表)
sep：分隔符， maxsplit：分割次数
split(sep = None, maxsplit = -1)
rsplit(sep = None, maxsplit = -1)

#按行进行分割(以列表的形式返回)
x.splitlines()

#拼接(在大量数据中比+效率高)
"拼接符".join(...)
".".join(["www", "bing", "com"])
'www.bing.com'

'''
格式化字符串
'''
# 位置
"aaa{}aaa{}".format('b', 'c')
'aaabaaac'

# 下标
"aaa{1}aaa{0}".format('b', 'c')
'aaacaaab'

# 关键字
"aaa{n1}aaa{n2}".format(n1 = 'b', n2 = 'c')

# {}输出方法
"{}, {}, {}".format(1, "{}", 2)
"{}, {{}}, {}".format(1, 2)


# [[fill]align][sign][#][0][width][grouping_option][.precision][type]
#要带:，因为左边是位置索引

align #对齐方式

woidth #指定字符串的空间
"{l:>10}{r:<10}".format(l = 520, r = 250)

0 #为数字提供感知正负号的0填充
"{:010}".format("-25")

fill #选择填充的字符
"{1:%>10}".format(520)

sign #符号选项
"{:+}{:-}".format(520, -250)

type #精度选项
"{:.2f}".format(3.1415)
"{:.2g}".format(3.1415)

grouping_option #整数类型
"{:b}".format(80)
"{:c}".format(80)

'#' #给进制加上前缀
"{:#o}".format(80)

grouping_option #浮点数类型
"{:e}".format(12345)
"{:.2%}".format(0.96)

"{:.{prec}f}".format(3.1415, prec = 2) # 通过关键字参数设置


# f-字符串(3.6以后,语法糖)
f"aaa{year}aaa"
f"{-520:010}"

align：

值	含义
<	强制字符串在空间左对齐（默认）
>	强制字符串在空间右对齐
=	强制将字符串放在符号和数字之间（-0000120）
^	强制字符串在可用空间居中

sign:

值	含义
+	…
-	…
空格	在整数前面添加一个空格，在负数前面添加负号
, or _	千分位分隔符

type：

值	作用
f or F的浮点数	限定小数点后现实多少位
g or G的浮点数	(通用格式)限定小数点前后一共现实多少位
非数字类型	限定最大字段的大小
整数类型	不允许使用

grouping_option:

值	含义
b	二进制
c	Unicode
d	十进制
o	八进制
x or X	十六进制
n	跟d类似，不同之处在于它会使用当前语言环境设置的分隔符进入恰当的位置
None	跟d一样

​ grouping_option：

值	含义
e	科学计数法(小写e)
E	科学计数法(大写E)
f or F	定点表示法
g or G	(通用格式) 小数用f / F形式输出，大数用e / E形式输出
%	以百分号的形式表示

序列

基础

列表，元组，字符串都统称为序列

列表是可变序列，元组，字符串是不可变序列

# + *
(1, 2, 3) + (4, 5, 6)
"123" + "456"
(1, 2, 3) * 3
"123" * 3

'''
增量复制问题：
在 s *= 2 中
列表的id不会变，但是元组和字符串因为本身是不可变的所以返回给s的是一个新元组或字符串，id不一样
'''

# id判断
x is y
x not is y

# 包含判断
x in y
x not in y

# 删除

del x, y # 一个或多个指定对象

x = [1, 2, 3, 4, 5]
del x[1:4] # 对象的指定元素

函数

'''
相互转换
将一个可迭代对象转换
'''
# 列表
list("Hello")
list((1, 2, 3, 4, 5))

# 元组
tuple([1, 2, 3])

# 字符串(只是在左右添加')
str([1, 2, 3])
str((1, 2, 3))

'''
最小值和最大值
可迭代对象
'''
s = [1, 1, 2, 3, 5]
min(s)

t = "FishC"
max(t) # ascii

s = []
min(s) # 传空会报错，可以添加default
min(s, default = "无最小")

'''
len & sum
len的范围 32位：2^31 - 1 64位:2^63 - 1
'''
len(range(100))

sum([1, 2, 3, 4, 5], start=None) # start：从多少开始加

'''
排序
'''
# 返回一个新的序列
sorted(s, reverse=True, key=len) # 支持任何可迭代对象

# 返回一个迭代器
reversed(s) # 支持任何可迭代对象

'''
all() & any()
判断是否所有元素的值都为真值 & 判断可迭代对象中是否有某个元素的值为真
'''
a = [1, 1, 0]
b = [1, 1, 9]
all(a) # False
all(b) # True
any(a) # True
any(b) # True

'''
enumerate()
将可迭代对象中的每个元素即从零开始的序号共同构成一个二元组的列表
'''
s = ["name", "hello", "world"]
list(enumerate(s))
# [(0, 'name'), (1, 'hello'), (2, 'world')]
list(enumerate(s)， 10)
# [(10, 'name'), (11, 'hello'), (12, 'world')]

'''
zip()
用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组
'''
a = [1, 2, 3]
b = [4, 5, 6]
list(zip(a, b))
# [(1, 4), (2, 5), (3, 6)]

c = "qwe"
list(zip(a, b, c))
# [(1, 4, q), (2, 5, w), (3, 6, e)]

# 若长度不一样则以最短的为主
c = "qwert"
list(zip(a, b, c))
# [(1, 4, q), (2, 5, w), (3, 6, e)]

# 保留的方法
import itertools
zipped = itertools.zip_longest(x, y, z)
list(zipped)
# [(1, 4, q), (2, 5, w), (3, 6, e), (None, None, r), (None, None, t)]

'''
map()
会根据提供的函数对指定的可迭代对象的每个元素进行运算,并返回运算结果的迭代器
'''
list(map(ord, "FishC"))
# [70, 105, 115, 104, 67]

list(map(pow, [2, 3, 10], [5, 2, 3]))
# [32, 9, 1000]

# 若长度不一样则以最短的为主
list(map(pow, [2, 3, 10], [5, 2, 3, 5, 8, 10]))
# [32, 9, 1000]

'''
filter()
会根据提供的函数对指定的可迭代对象的每个元素进行运算,并将运算结果为真的元素以迭代器的形式返回
'''
list(filter(str.islower, "FishC"))
# ['i', 's', 'h']

迭代器与可迭代对象

迭代器是可迭代对象

可迭代对象可以多次使用，迭代器只能使用一次

'''
iter()
将可迭代对象变为迭代器
'''
x = [1, 2, 3, 4, 5]
y = iter(x)

'''
next()
逐个将迭代器中的元素给提取出来
next(x, "没有了")
'''
y = iter(x)
next(y) # 1
next(y) # 2
...

字典（上）_哔哩哔哩_bilibili