知识
if __name__ == '__main__':
这是Python中的条件语句,用于在当前脚本被直接执行时,而非作为模块引入时执行以下代码块中的内容。
表达式 x = [x] * n
创建一个列表 x
,其中包含 n
个元素,每个元素都是变量 x
的引用。
arr的高级索引
arr = np.array([[1, 5, 3],
[2, 9, 4],
[6, 7, 8]])
print(arr[[0,1,2],[0,0,0]])
#arr[1][2] 和 arr[1, 2]等效
X_cluster_dist = X_digits_dist[np.arange(len(X_train)), kmeans.labels_]
#急死我了,看了一下午,以为labels是特征数,是固定值
后来猛地就意识到这玩意,还真是
格式化输出(占位符)
目前常用的占位符写法有三种
- %
-
>>> "%s %s %s" % ("hello", 3, 3.1415) 'hello 3 3.1415'
%g
表示通用格式,根据值的大小自动选择输出为浮点数还是科学计数法表示(取决于值的大小)。对于整数,不输出小数部分。%x
表示将整数以十六进制形式输出。'%gx%g' % im.shape[2:]
这里的'%gx%g'
部分将im.shape[2:]
中的值使用这两种格式来输出。具体的输出取决于im.shape[2:]
的值,如果是浮点数或较大的整数,则可能会使用科学计数法或十六进制形式的表示方式。
s | 字符串(使用str() 方法转换任何Python对象)【十分常用】 |
d | 十进制整数 |
f | 十进制浮点数(小数), 自动保留六位小数。 |
- format 。一种位置参数,一种关键词参数
-
>>> "{} {}".format("Li hua", 24) 'Li hua 24' >>> "{0} {1} {1} {0}".format("Li hua", 24) 'Li hua 24 24 Li hua' >>> "{name} {age}".format(name="Li hua", age=24) 'Li hua 24' >>> "{name} {age} {age} {name}".format("Li hua", 24) 'Li hua 24 24 Li hua'
- f表达式(一般这就够用了)
-
f'{name} is {age} years old' print(f'h={h:.5f}, numerical limit={numerical_lim(f, 1, h):.5f}') 表示这个字符串包含两个插值表达式 h numerical_lim(f, 1, h) 必须:.后面跟精度 print() f'' h={},numerical limit={} :3.5f .5为保留几位小数,即精度 3为总长度。 h=3.4254 print(f'h={h:.5f}, h={h:f},h={h:3.2f}') #h=3.42540, h=3.425400,h=3.43
*位置参数和关键字参数
位置参数传参顺序不可变,关键词参数传参可变
默认的是位置参数和关键字参数
#可选的位置和关键字参数
def f(a=1): pass
f() # 正确
f(1) # 正确
f(a=1) # 正确
#必需的位置和关键字参数
def f(a): pass
f() # 错误,需要传入参数
f(1) # 正确
f(a=1) # 正确
def name(p1, p2, /, p_or_kw, *, kw):
def name(p1, p2=None, /, p_or_kw=None, *, kw):
def name(p1, p2=None, /, *, kw):
def name(p1, p2=None, /):
def name(p1, p2, /, p_or_kw):
def name(p1, p2, /):
def name(p_or_kw, *, kw):
def name(*, kw):
某个位置参数有了默认值,后面的除了kw都要有默认值
下面属于无效定义
def name(p1, p2=None, /, p_or_kw, *, kw):
def name(p1=None, p2, /, p_or_kw=None, *, kw):
def name(p1=None, p2, /):
位置参数(positional): 传参时前面不带 "变量名=", 顺序不可变, 按顺序赋给相应的局部变量.
关键字参数(keyword): 传参时前面加上 "变量名=", 顺序可变, 按名称赋给同名的局部变量.
#positional_or_keyword_argument 位置参数和关键字参数
在“/”左边的参数被视为仅位置参数
如果函数定义中“/”没有指定,则函数中所有参数都不是仅位置参数
仅位置参数的可选值的逻辑与位置-关键字参数的逻辑相同。
没有默认值的仅位置参数在调用的时候必需给值。
#1.集合位置参数(VAR_POSITIONAL)
def fun(*args):
print(args)
fun(10,10,50)
#(10, 10, 50)
#2.集合关键字参数(VAR_KEYWORD)
def fun1(**args): #可变个数的关键字参数 ,仅一个
print(args)#但是可以一起出现(*d,**da)反过来会报错
fun1(a=10,b=20,c=30)#出来一个字典
#{'a': 10, 'b': 20, 'c': 30}
3.混合
def fun2(*arg,**kwargs):
print(arg,kwargs)
fun2(10,a=20)
#(10,) {'a': 20}
例子
#必须的位置参数
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
# a, b 是 仅位置参数;c, d 是 位置或关键字参数; e, f 是 仅关键字参数
f(10, 20, 30, d=40, e=50, f=60)
#可选的位置参数
def f(a=2, /): pass
f() # 允许调用方式,参数是可选的
f(1) # 允许调用方式,参数是位置参数
f(a=1) # 错误的调用方式,参数是仅位置参数
#可选的关键字参数
def f(*, a=1): pass
f() # 正确
f(1) # 错误,参数是仅关键字参数
f(a=1) # 正确
#必需的关键字参数
def f(*, a): pass
f() # 错误,需要传入参数
f(1) # 错误,仅关键字参数
f(a=1) # 正确
1.hasattr
"has attribute" 的缩写,用于检查一个对象是否具有指定的属性或方法。
class MyClass:
def __init__(self):
self.x = 5
obj = MyClass()
print(hasattr(obj, 'x')) # True,对象 obj 具有属性 'x'
print(hasattr(obj, 'y')) # False,对象 obj 不具有属性 'y'
print(hasattr(obj, '__init__')) # True,对象 obj 具有方法 '__init__'
2.isinstance
"is instance" 的缩写,用于检查一个对象是否属于指定的类型。
class MyClass:
pass
obj = MyClass()
print(isinstance(obj, MyClass)) # True,对象 obj 是 MyClass 类的实例
print(isinstance(obj, object)) # True,对象 obj 是 object 类的实例(所有类的基类)
print(isinstance(obj, int)) # False,对象 obj 不是 int 类的实例
在布尔运算中,~
可以将一个布尔值取反,即将 True
转换为 False
,将 False
转换为 True
list.count(element)
if classList.count(classList[0]) == len(classList):
return classList[0]
计算classlist列表中第一个元素出现的的次数并返回
集合set()
去除重复元素
my_list = [1, 64, 3200, 258, 1] # 包含重复元素的列表
my_set = set(my_list) #不能维护顺序
print(my_set) # 输出:{64, 1, 258, 3200}
my_string = 'hello' # 包含重复字符的字符串
my_set = set(my_string)
print(my_set) # 输出: {'h', 'e', 'l', 'o'}
set
不会维护元素的顺序,因此无法通过索引访问。
sublabels = labels[:]
创建一个副本
sorted()
numbers = [-5, 2, -9, 1, 7]
sorted_numbers = sorted(numbers, key=abs)
print(sorted_numbers) # 输出:[1, 2, -5, 7, -9]
info = {'name': 'John', 'age': 25, 'country': 'USA'}
sorted_info = sorted(info.items(), key=lambda x: x[1])
print(sorted_info) # 输出:[('age', 25), ('name', 'John'), ('country', 'USA')]
letters = ('d', 'b', 'c', 'a')
sorted_letters = sorted(letters, reverse=True)
print(sorted_letters) # 输出:['d', 'c', 'b', 'a']
#默认升序,然后reverse
#key是排序函数
突然想起学python的时候了,死去的记忆开始攻击我。。。。。
for in zip() 并行遍历
def m():
return 1,2
c=m()
print(c)
#(1,2)
多参数返回一个元组
因此 (test_acc,)
将会创建一个包含单个元素 test_acc
的元组,而 (test_acc)
则只是将 test_acc
放入括号中,没有创建元组的效果。
zip(self.data, args)
: 这里使用zip()
函数将self.data
和args
中的元素一一对应地组合成元组。然后遍历元组-
在 Python 中,
(test_acc,)
和(test_acc)
之间有一个微妙但重要的区别: -
(test_acc,)
: 这是一个包含单个元素test_acc
的元组。逗号,
是用来区分包含单个元素的元组和普通括号组合的方式。这种语法确保(test_acc,)
表示一个元组,而不是仅仅将test_acc
当作数值或变量。(test_acc)
: 这实际上不是一个元组,而只是表达式(test_acc)
的括号。在这种情况下,括号被视为普通的数学运算符或用于优先级的分组方式。这并不会创建元组。
list_1 = [1, 2, 3, 4]
list_2 = ['a', 'b', 'c']
for x, y in zip(list_1, list_2):
print(x, y)
#输出如下
1 a
2 b
3 c
list_1 = [1, 2, 3, 4]
list_2 = [1,2,3]
a=(1,2,3)
b=(1,2,3)
d=a+b
c= [x+y for x, y in zip(list_1, list_2)]
print(c)
print(d)
#[2, 4, 6]
#(1, 2, 3, 1, 2, 3)
operator.itemgetter()
是 Python 中 operator
模块提供的一个函数,用于获取对象的指定位置或键的元素。它可以用于获取元组、列表、字典等对象中的元素。
my_list = ['apple', 'banana', 'cherry']
getter = itemgetter(0, 2) # 创建 itemgetter 对象,指定位置为 0 和 2
print(getter(my_list)) # 输出:('apple', 'cherry')
my_list = [{'name': 'John', 'age': 25},
{'name': 'Jane', 'age': 30},
{'name': 'Bob', 'age': 35}]
getter = itemgetter('age')
ages = list(map(getter, my_list))
print(ages) # 输出:[25, 30, 35]
map()
map(function, iterable)
map()函数可以用于任何可迭代对象,包括列表、元组、集合等
def square(x):
return x ** 2
my_list = [1, 2, 3, 4, 5]
squared_list = map(square, my_list)
print(list(squared_list)) # 输出:[1, 4, 9, 16, 25]
需要注意的是,如果 my_list 是一个非常大的列表,
将它作为参数传递给 map() 函数可能会占用大量的内存。
在这种情况下,可以考虑将 my_list 转换为迭代器,以减少内存的使用。
可以通过使用 iter() 函数将列表转换为迭代器,然后再传递给 map() 函数。
my_list_iterator = iter(my_list)
result = map(square, my_list_iterator)
next()
在使用 next()
函数之前,必须先通过 iter()
函数将可迭代对象转换为迭代器
当迭代器耗尽时,next()
函数会引发 StopIteration
异常。为了避免此异常,通常会在调用 next()
函数时使用默认值参数。
myList = [1, 2, 3]
myIterator = iter(myList)
print(next(myIterator, '默认值')) # 输出:1
print(next(myIterator, '默认值')) # 输出:2
print(next(myIterator, '默认值')) # 输出:3
print(next(myIterator, '默认值')) # 输出:默认值
myDict = {'a': 1, 'b': 2, 'c': 3}
print(next(iter(myDict))) #a
print(next(iter(myDict)))#只会传a,即第一个键
iter()
iter()
函数将 my_list
转换为一个迭代器对象 my_iter
,
然后我们先使用 next()
函数逐个访问了列表的前两个元素,接着通过 for
循环遍历了迭代器对象中剩余的元素。
iter()
函数通常与 next()
函数一起使用,但也可以和其他遍历手段结合使用,如 for
循环。
my_list = [1, 2, 3, 4, 5]
# 使用iter()将列表转换为迭代器对象
my_iter = iter(my_list)
# 使用next()函数逐个访问元素
print(next(my_iter)) # 输出: 1
print(next(my_iter)) # 输出: 2
# 使用for循环遍历迭代器对象元素
for item in my_iter:
print(item)
#最后输出1,2,3,4,5
#两种迭代方法,效果一样
join()
separator.join(iterable)
其中,separator
是连接字符串之间的分隔符,可以是任意字符串,而 iterable
是一个可迭代对象,例如列表、元组或生成器。
my_list = ['John', 'Amy', 'Bob']
joined_string = ', '.join(my_list)
print(joined_string)
输出:John, Amy, Bob(字符串)
super()继承
在子类中保持了父类方法的行为,并对其进行了扩展。不继承就会覆盖父类
通过使用super()
函数,我们可以轻松地在子类中访问父类的方法,而不需要直接指定父类的名称。这样,即使继承关系发生变化,我们仍然可以良好地维护代码。
super的参数可有可无,Python会根据当前上下文自动推断出父类和当前实例对象。
不过需要注意的是,如果因为某种原因无法确定父类或实例对象,或者需要调用多个父类的方法,就需要显式地指定参数。
class Animal:
def __init__(self, name):
self.name = name
def make_sound(self):
print("Animal makes sound")
class Dog(Animal):
def __init__(self, name):
super(Dog,self).__init__(name)
def make_sound(self):
super().make_sound()
print("Dog barks")
# 创建Animal实例
animal = Animal("Tom")
animal.make_sound() # 输出: Animal makes sound
# 创建Dog实例
dog = Dog("Max")
dog.make_sound() # 输出: Animal makes sound
# Dog barks
yield
yield
是一个关键字,用于在 Python 中定义生成器函数。通过使用 yield
关键字,我们可以将生成器函数分成多个部分,并在每次调用生成器函数时返回一个值。
每一次for num in numbers: 就调用一次,numbers是一个生成器对象。
def generate_numbers(n):
for i in range(n):
yield i
# 调用生成器函数
numbers = generate_numbers(5)
# 遍历生成器函数的返回值
for num in numbers:
print(num)
with try raise
Python 中的 with 语句用于异常处理,封装了 try…except…finally 编码范式,提高了易用性。
file = open('./test_runoob.txt', 'w')
file.write('hello world !')
file.close()
以上代码如果在调用 write 的过程中,出现了异常,则 close 方法将无法被执行,因此资源就会一直被该程序占用而无法被释放。
file = open('./test_runoob.txt', 'w')
try:
file.write('hello world')
finally:
file.close()
以上代码我们对可能发生异常的代码处进行 try 捕获,发生异常时执行 except 代码块,finally 代码块是无论什么情况都会执行,所以文件会被关闭,不会因为执行异常而占用资源。
try:
#执行某些代码
pass
except ValueError:
# 处理ValueError异常
pass
except (TypeError, ZeroDivisionError):
# 处理多个异常
# TypeError 和 ZeroDivisionError 异常
pass
except:
# 处理所有其他异常
pass
try:
a = int(input("输入一个正整数: "))
if a <= 0:
raise ValueError("这不是一个正数!")
except ValueError as ve:
print(ve)
#输入一个正整数: -2
#这不是一个正数!
lambda
lambda [arg1 [,arg2,.....argn]]:expression
lambda x, y: x*y # 函数输入是x和y,输出是它们的积x*y
lambda:None # 函数没有输入参数,输出是None
lambda *args: sum(args)
# 输入是任意个数参数,
输出是它们的和(隐性要求输入参数必须能进行算术运算)
lambda **kwargs: 1 # 输入是任意键值对参数,输出是1
# 为了把标准库time中的函数sleep的功能屏蔽(Mock),我们可以在程序初始化时调用:
time.sleep=lambda x: None
# 这样,在后续代码中调用time库的sleep函数将不会执行原有的功能。
# 例如:
time.sleep(3)
# 程序不会休眠 3 秒钟,而是因为lambda输出为None,所以这里结果是什么都不做
# ===========一般用法:===========
# 1、过滤出列表中的所有奇数
def is_odd(n):
return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
# 结果: [1, 3, 5, 7, 9]
# ===========匿名函数用法:===========
# 2、将列表[1, 2, 3]中能够被3整除的元素过滤出来
newlist = filter(lambda x: x % 3 == 0, [1, 2, 3])
print(list(newlist))
# 结果: [3]