百度飞桨领航团零基础Python速成营课程总结

百度飞桨领航团零基础Python速成营课程总结

【飞桨】、【百度领航团】、【零基础Python】
https://aistudio.baidu.com/aistudio/course/introduce/7073

---

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

第一天

基本数据类型相同，字符串可用单引号或者双引号都可，字符串中需要用到双引号，可用采用单双引号交替使用，或者利用转义符。

'爸爸说："今天我做饭"'
"爸爸说：\"今天我做饭\""

Python 中标识符的命名不是随意的，而是要遵守一定的命令规则，比如说：

标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。 标识符不能和 Python 中的保留字相同。 Python中的标识符中，不能包含空格、@、% 以及 $ 等特殊字符。 在 Python 中，标识符中的字母是严格区分大小写的

数据类型的转换: 类型()

int(2.5)
str(4)
bool(3)  # 非0： Ture 其它 False
float('0.6')

列表list与元组tuple：

• list是一种有序的集合，可以随时添加和删除其中的元素。
• 另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改

可变对象：list dict set

不可变对象：tuple string int float bool

字典dict：

word = {
     'apple':'苹果','banana':'香蕉'}
scores = {
     '小张':100, '小李':80}
grad = {
     4:'很好',3: '好',2:'中',1:'差',0:'很差'}
scores['小张']

集合set：set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

/列表集合类型转换同上

s = {
     1,1,2,3,4}
set([1,1,2,3,4])
list({
     1,1,2,3,4})
list((1,2,3))

while循环与if判读基本与c相同。

for循环可用在列表与字符串中：

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第一个实例
   print( '当前水果 :', fruit)
   
for letter in 'Python':     # 第二个实例
   print( '当前字母 :', letter)

continue，break同。

第二天

字符串进阶

索引，切片

切片的语法：[起始:结束:步长] 字符串[start: end: step] 这三个参数都有默认值，默认截取方向是从左往右的 start:默认值为0； end : 默认值未字符串结尾元素； step : 默认值为1；如果切片步长是负值，截取方向则是从右往左的。

字符串一些函数：

string = 'hello_world'
string.endswith('ld') # 返回布尔值
string.startswith('he') # 返回布尔值
string.count('o') #显示自定义字符在字符串中个数
string.find('o') #返回从左第一个指定字符的索引，找不到返回-1
string.index('o') #返回从左第一个指定字符的索引，找不到报错
'hello' in string #返回布尔值，在字符串中是否存在
string.split('_') #按照指定的内容进行分割
string.replace('_',' ') #从左到右替换指定的元素，可以指定替换的个数，默认全部替换

my_string = "I wish to wish the wish you wish to wish, but if you wish the wish the witch wishes, I won't wish the wish you wish to wish."
my_string.replace('wish','wish'.upper(), 3)

#字符串标准化
my_string = ' hello world\n'
my_string.strip()

#大小写
my_string = 'hello_world'
my_string.upper()#大写
my_string.lower()#小写
my_string.capitalize()#首字母大写

字符串的格式化输出

一种可读性更好的方法 f-string

name = 'Molly'
hight = 170.4
score_math = 95
score_english = 89
print(f"大家好！我叫{name}，我的身高是{hight:.3f} cm, 数学成绩{score_math}分,英语成绩{score_english}分")

list进阶

list1 = ['a','b','c','d','e','f']
list1.append('g') # 在末尾添加元素
list1.insert(2, 'ooo')  # 在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
list2 = ['z','y','x']
list1.extend(list2) #合并两个list   list2中仍有元素
list1.count('a')#返回a的数量
list1.index('a')#返回第一个a的索引
'a' in list1#返回布尔值
list1.pop(3)#取出倒数第三个元素，并在原list中删除
list1.remove('a')#删除第一个自定义字符

列表每一项的操作

# 有点土但是有效的方法
list_1 = [1,2,3,4,5]
for i in range(len(list_1)):
    list_1[i] += 1
list_1  

# pythonic的方法 完全等效但是非常简洁
[n+1 for n in list_1]
#引申
# 1-10之间所有数的平方 
[(n+1)**2 for n in range(10)]
# 1-10之间所有数的平方 构成的字符串列表
[str((n+1)**2) for n in range(10)]

# 小练习：0-29之间的奇数
list_1 = range(30)
[n for n in list_1 if n%2!=0]
#总结
[对n做的操作 for n in 目标list n的判断条件]

# 取两个list的交集
list_A = [1,3,6,7,32,65,12]
list_B = [2,6,3,5,12]
[i for i in list_A if i in list_B]

#小练习 在list_A 但是不在list_B中
list_A = [1,3,6,7,32,65,12]
list_B = [2,6,3,5,12]
[i for i in list_A if i not in list_B]
#双层for循环
[m + n for m in 'ABC' for n in 'XYZ']

生成器

L = [x * x for x in range(10)] #列表
g = (x * x for x in range(10)) #生成器
#可用next()每一个访问
next(g)
#也可用for循环输出
for n in g:
    print(n)
# 练习 斐波那契数列
def feb(max_num):
    n_1 = 1
    n_2 = 1
    n = 0
    while n<max_num:
        if n == 0 or n == 1:
            yield 1
            n += 1
        else:
            yield n_1 + n_2
            new_n_2 = n_1 
            n_1 = n_1 + n_2
            n_2 = new_n_2
            n += 1
#yield可以理解为return，但是return后会继续执行

第三天

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def student_name_and_age():
    "记录学生的名字和年龄"
    name = input('请输入姓名\n')
    age = int(input('请输入年龄\n'))
    print(f'姓名:{name};年龄:{age}')
    return name,age
## 函数的嵌套调用
def worker(s):
    rst = 10 / float(s)
    return rst

def group_leader(s):
    rst = worker(s) * 2
    return rst

def CTO(s):
    return group_leader(s)

参数传递

# 位置参数是最简单的一种函数调用的方式。位置参数须以正确的顺序传入函数、数量必须和声明时的一样。
def student_name_and_age(name, age):
    print('姓名：%s 年龄 %s' %(name, age))
#调用函数时，缺省参数的值如果没有传入，则被认为是默认值，直接在参数后用等号赋值。
def student_name_and_age(name, age='不愿透露'):
    "设置默认参数"
    print('姓名：%s 年龄 %s' %(name, age))
#可变参数，顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个，用法是在参数前加*，可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。。
def all_student_names(*names):
    for name in names:
        print('姓名：', name)
#关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict，用法为前面加**。
def student_info(name, age, **kw):
    print(f'我的名字叫：{name},年龄：{age},其它信息：{kw}')
    if 'city' in kw:
        print('来自：', kw['city'])
#命名关键字参数，如果要限制关键字参数的名字，就可以用命名关键字参数，用*，隔开
def print_person_info(name, age, *, height, weight):
    print('我的名字叫：', name, '年龄：', age,'身高', height, '体重', weight)

参数的组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def student_info(name, age=18, *books, city, **kw):
    # 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
    print('我的名字叫：', name, '年龄：', age,'其它信息：',kw)
    print('来自：', city)
    for book in books:
        print('我有',book,'书')

变量的作用域和global变量

1.局部变量 作用域:在函数内

2.全局变量 作用域:在函数外

函数优先使用局部变量 在没有局部变量的情况下， 使用全局变量

lambda匿名函数

python 使用 lambda 来创建匿名函数。

lambda 只是一个表达式，函数体比 def 简单很多。

lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# lambda 若干个输入参数 : 返回值的表达式
lambda arg1, arg2: arg1 + arg2
(lambda arg1, arg2: arg1 + arg2 )(1, 2)
# 加法运算 接受两个参数，返回参数之和
add = lambda arg1, arg2: arg1 + arg2
add(1,2)

高阶函数

• 函数可以赋值给变量，变量就是函数
• 函数的名字也可以作为一个变量，传入其它函数
• 一个函数可以接收另一个函数作为参数，这种函数就称之为高阶函数。

map / reduce

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

fx = lambda x:x**2
ls = [1,2,3,4,5,6,7,8,9]
rst = map(fx, ls)
list(rst)

reduce: 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，依此类推，最后得到一个结果。

from functools import reduce
# 从python3开始，reduce函数移动到了functools这个包，每次使用前要先import
mul_xy = lambda x, y: x*y
reduce(mul_xy, [1, 3, 5, 7, 9])#输出结果：945

sorted

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

sorted([36, 5, -12, 9, -21])
#[-21, -12, 5, 9, 36]
sorted([36, 5, -12, 9, -21], reverse=True)
#[36, 9, 5, -12, -21]
sorted([36, 5, -12, 9, -21], key=abs)   # 按绝对值排序key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序
#[5, 9, -12, -21, 36]

points = [(5,2), (7,3), (3,4),(1,1),(2,6)]  # 按x坐标排序 y坐标排序 和0点距离排序
f_x = lambda x:x[0]
sorted(points, key=f_x)

f_y = lambda x:x[1]
sorted(points, key=f_y)

f_r = lambda x:x[0]**2+x[1]**2
sorted(points, key=f_r)

闭包

暂时没理解，代码如下

# 一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。

def count():
    fs = []
    for i in range(1, 4):
        def f():
            # print(id(i))
            return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())
#9，9，9

def count():
    def f(j):
        def g():
            # print(id(j))
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())
#1,4,9
#返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

装饰器

顾名思义，从字面意思就可以理解，它是用来"装饰"Python的工具，使得代码更具有Python简洁的风格。换句话说，它是一种函数的函数，因为装饰器传入的参数就是一个函数，然后通过实现各种功能来对这个函数的功能进行增强。

# 装饰器输入一个函数，输出一个函数
def print_working(func):
    def wrapper():
        print(f'{func.__name__} is working...')
        func()
    return wrapper

def worker1():
    print('我是一个勤劳的工作者！')
def worker2():
    print('我是一个勤劳的工作者！')
def worker3():
    print('我是一个勤劳的工作者！')

worker1 = print_working(worker1)
worker1()
worker2= print_working(worker2)
worker2()
#也可以这样
@print_working
def worker1():
    print('我是一个勤劳的工作者！')
@print_working
def worker2():
    print('我是一个勤劳的工作者！')
@print_working
def worker3():
    print('我是一个勤劳的工作者！')
worker1()
worker2()
worker3()

装饰器最大的优势是用于解决重复性的操作，其主要使用的场景有如下几个：

• 计算函数运行时间
• 给函数打日志
• 类型检查

当然，如果遇到其他重复操作的场景也可以类比使用装饰器。

#带参装饰器
def arg_decorator(func):
    def wrapper(*args, **kw):
        print(f'{func.__name__} is working...')
        func(*args, **kw)
    return wrapper

@arg_decorator
def student_info(name, age=18, *books, **kw):
    print(f'我的名字叫{name}, 今年{age}岁，我有很多本书：')
    for book in books:
        print(book)
    print(kw)

student_info('Molly',18, '语文书','数学书',height=170)
#student_info is working...
#我的名字叫Molly, 今年18岁，我有很多本书：
#语文书
#数学书
#{'height': 170}

偏函数

通过设定参数的默认值，降低函数调用的难度，当有固定函数存在，不想修改原函数，同时想添加默认值时使用。

def student_info(name, age, city):
    print(f'我的名字叫{name}, 今年{age}岁，来自{city}')

from functools import partial
def student_info(name, age, city):
    print(f'我的名字叫{name}, 今年{age}岁，来自{city}')

student_info_beijing = partial(student_info, city='北京')
student_info_beijing('Molly',18)
#我的名字叫Molly, 今年18岁，来自北京
student_info_beijing('Molly',18, city='上海')
#我的名字叫Molly, 今年18岁，来自上海

第四天

如何定义类

class Athlete:

• 第一部分：class定义类的关键字，Athlete符合python标识符命名规则，：表示类内容的开始

def init(self,a_name,a_dob=None,a_times=[]):

• 第二部分：def定义函数的关键字，init 方法是一个特殊方法会在实例化对象时自动调用，我们会在这个方法中对数据进行赋值。self作为类中函数的第一个参数，方便该方法调用该类的其他属性和方法。
• 第三部分：自定义的属性和方法

如何使用类

1.创建对象

对象名 = 类名(参数)

2.使用.调用类的方法和属性

对象.属性名

对象.方法名()

class Athlete:
    address = '中国足球协会训练基地xx街xx号'#类熟悉
    def __init__(self,a_name,a_dob=None,a_times=[]):
        self.__name = a_name#私用属性
        self.dob = a_dob
        self.times = a_times
       
    def sayName(self):
        print(self.__name)
        
    def top3(self):
        return sorted(set([self.__sanitize(t) for t in self.times]))[0:3]
        
    def __sanitize(self,time_string):#私用属性
        if '-' in time_string:
            splitter = '-'
        elif ':' in time_string:
            splitter = ':'
        else:
            return (time_string)
        (mins,secs) = time_string.split(splitter)
        return (mins+'.'+secs)
    @classmethod#类方法
    def changeAddress(self):
        self.address = '中国田径训练基地xx街xx号'

• 类熟悉：所有对象共享的数据。在 init 之上，或者说在类的范围内与方法同等级别，书写变量名=值
• 调用：类名.类属性
• 类方法：所有对象共享的方法：方法定义时，使用@classmethod标记。
• 调用：类名.类方法 或 对象.类方法
• 私用的属性和方法的定义：在属性和方法名前加 __ 两个下划线

第五天

子类

定义：

class 子类名(父类名)：

情况1，如果子类有新增的属性，那么需要在子类__init方法中，调用父类的__init__

情况2，如果子类没有新增的属性,子类不需要写__init__方法

使用：
对象名 = 子类名(参数)

继承的好处：代码重用，升级功能（重写），新增功能（新的方法）

#定义橄榄球运送员类
class Rugby(Athlete):
    def __init__(self,a_name,a_bod,a_squat,a_times):
        #调用父类__init__
        Athlete.__init__(self,a_name,a_bod,a_times)
        #深蹲次数
        self.squat = a_squat
    # 继承后下面两个函数就在Rugby类中，只是看不到而已
    # def top3(self):
    #     return sorted(set([self.sanitize(t) for t in self.times]))[0:3]
    # def sanitize(self,time_string):
    #     if '-' in time_string:
    #         splitter = '-'
    #     elif ':' in time_string:
    #         splitter = ':'
    #     else:
    #         return (time_string)
    #     (mins,secs) = time_string.split(splitter)
    #     return (mins+'.'+secs)

方法重写

子类方法与父类方法完全相同，子类若重写了父类的方法，则子类对象调用方法时就是调用的自己类中重新的方法。

class OtherAthlete(Athlete):
    def __init__(self,a_name,a_bod,a_squat,a_times):

        Athlete.__init__(self,a_name,a_bod,a_times)

        self.squat = a_squat
    def top3(self):
        return sorted([self.sanitize(t) for t in self.times])[0:3]

多继承

class Father(): 
    def talk(self):
        print("---爸爸的表达能力---")

class Mather():
    def smart(self):
        print("---妈妈聪明的头脑---")

class Child(Father,Mather):
    pass

child1 = Child()
child1.talk()
child1.smart()

#---爸爸的表达能力---
#---妈妈聪明的头脑---

多个父类有相同的属性或方法名，这种情况应该避免，会调用第一个父类方法。

---

总结

作为一门非常简便快速的语言，没有了；的限制，但是对缩进严格要求，课程不长，收获颇丰。