python

置顶潇洒哥611

已于 2024-05-19 16:08:30 修改

阅读量44

点赞数

文章标签： python 开发语言 1024程序员节 numpy 深度学习机器学习算法

于 2023-10-19 22:51:23 首次发布

本文链接：https://blog.csdn.net/qq_72985002/article/details/133936472

版权

知识

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]