「百度飞桨领航团零基础Python速成营」学习笔记

课程链接：https://aistudio.baidu.com/aistudio/course/introduce/7073

由于之前本人就有在使用Python，故一些基础的语法就不再记录。

字符串

翻转

s = 'Hello world'
rev_s = s[::-1]

格式化输出

num = 88
s = 'Hello'
# 在{}内可以写Python语句
print(f'{s} is a string, {num} is a number.'
print(f'{num * 100} is a number mutiply 100')

列表生成式

# 方式一
num = range(10)
# 0-10中所有奇数乘10，存入num_list中
num_list = [n * 10 for n in num if n%2 == 1]

以前对列表进行计算都是采用循环来实现，即

# 方式二
num_list = []
for n in num:
    if n%2 == 1:
        num_list.append(n * 10)

两种方式对比，方式一在性能上具有一定的优势。处理50000000的数据量时，方式一耗时5秒左右，方式二耗时8秒左右。

生成器

# 方式一，使用列表定义生成器
num_gene = (n * 10 for n in num if n%2 == 1)
next(num_gene)

# 方式二，使用函数定义生成器
def my_gene():
    n = 0
    while True:
        if n%2 == 1:
            yield n * 10
        n += 1

num_gene = my_gene()
next(num_gene)

生成器的优点在于不是一次性产生所有数据，不会占用太大的内存。

函数

参数

# 位置参数，传入的参数需要保持顺序，且不能缺省
def fun1(arg1, arg2):
	pass

# 默认参数，可以缺省
def fun2(arg1=1, arg2='b')
	pass

# 可变参数，个数不确定，将转为tupel传入
def fun3(*arg):
	pass

# 关键字参数，转为dict传入，传入时需指定参数名，fun4(arg1=1, arg2='b')
def fun4(**arg):
	pass

# 命名关键字参数，arg2传入时需要指定参数名，fun5(1, arg2=2)
def fun5(arg1, *, arg2):
	pass

匿名函数

# 定义格式为lambda 参数 : 表达式
add = lambda arg1 arg2: arg1+arg2
add(1, 2)

高阶函数

# map，对每个对象进行操作
def fun(n):
    return n * 10

list(map(fun, range(10)))

# reduce，将前一次的结果作为本次的第一个参数
# 0   1   2   3   4
#   1
#       3
#           6
#               10
def fun(n, m):
    return n + m

from functools import reduce
reduce(fun, range(5))

装饰器

# 输入一个函数，返回一个函数
# 常见应用场景：计时、日志
import time
# 计时装饰器的定义
def timer(func):
    def wrapper(data):
        s_time = time.time()
        result = func(data)
        e_time = time.time()
        print(f'{func.__name__} worktime is {(e_time - s_time) * 1000}')
        return result
    return wrapper

@timer
def function(data):
	pass

偏函数

# 指定部分参数
def func(arg1, arg2):
    pass
    
from functools import partial
f = partial(func, arg2='b')
f(1)

面向对象

类属性

# 所有c类的对象共用a属性，某个对象调用cha方法后，该对象不再共用a属性
class c:
	a = 'a'
    def __init__(self):
        pass
    
    def cha(self, b):
    	self.a = b

类方法

# 使用@classmethod装饰过的方法为类方法，可使用类名直接调用
class c:
    def __init__(self):
        pass

    def fun1(self):
        print(self.fun1.__name__)
    
    @classmethod
    def fun2(self):
        print(self.fun2.__name__)
# fun1不是类方法，使用类名调用会报错
# c.fun1()

c.fun2()

权限

# 属性或方法前方加上双下划线__，即声明为私有
class c:
    def __init__(self, name):
    	self.__name = name

    def __fun(self):
        pass

继承

class a:
    def __init__(self, arg1):
        self.arg1 = arg1
        pass

    def fun(self):
        print(self.fun.__name__)

# 继承
class b(a):
    def __init__(self, arg1, arg2):
        a.__init__(self, arg1)
        self.arg2 = arg2

B = b(1, 'b')
B.fun()

# 多继承
class father:
	def __init__(self):
		self.a = 'F'
	
	def funcF(self):
		pass

class mother:
	def __init__(self):
		self.a = 'MF'
		self.b = 'M'
	
	def funcM(self):
		pass

class child(father, mother):
	pass

c = child()
# c.a为重名属性，取决于第一个父类
# 此处c.a为'F'
c.a
c.b
c.funcF()
c.funcM()

以上是本次学习的主要收获，还有部分面向对象的内容没有整理，有机会再补全。