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

百度飞桨领航团零基础Python速成营课程总结 【飞桨】、【百度领航团】、【零基础Python】
https://aistudio.baidu.com/aistudio/course/introduce/7073


文章目录

  • 百度飞桨领航团零基础Python速成营课程总结
  • 前言
  • 第一天
  • 第二天
    • 字符串进阶
      • 索引,切片
      • 字符串一些函数:
      • 字符串的格式化输出
      • 一种可读性更好的方法 f-string
    • list进阶
      • 列表每一项的操作
  • 第三天
    • 函数
    • 参数传递
    • 参数的组合
    • 变量的作用域和global变量
    • lambda匿名函数
    • 高阶函数
    • map / reduce
    • sorted
    • 闭包
    • 装饰器
    • 偏函数
  • 第四天
    • 如何定义类
    • 如何使用类
  • 第五天
    • 子类
      • 方法重写
    • 多继承
  • 总结

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

提示:以下是本篇文章正文内容,下面案例可供参考
第一天 基本数据类型相同,字符串可用单引号或者双引号都可,字符串中需要用到双引号,可用采用单双引号交替使用,或者利用转义符。
'爸爸说:"今天我做饭"' "爸爸说:\"今天我做饭\""

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;如果切片步长是负值,截取方向则是从右往左的。
Python|百度飞桨领航团零基础Python速成营课程总结
文章图片

字符串一些函数:
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()#首字母大写

字符串的格式化输出
Python|百度飞桨领航团零基础Python速成营课程总结
文章图片

一种可读性更好的方法 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) #合并两个listlist2中仍有元素 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

第三天 函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
【Python|百度飞桨领航团零基础Python速成营课程总结】函数能提高应用的模块性,和代码的重复利用率。你已经知道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 rstdef group_leader(s): rst = worker(s) * 2 return rstdef 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返回。
Python|百度飞桨领航团零基础Python速成营课程总结
文章图片

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 函数运算,依此类推,最后得到一个结果。
Python|百度飞桨领航团零基础Python速成营课程总结
文章图片

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 fsf1, f2, f3 = count() print(f1()) print(f2()) print(f3()) #9,9,9def 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 wrapperdef 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_timesdef 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): passchild1 = Child() child1.talk() child1.smart()#---爸爸的表达能力--- #---妈妈聪明的头脑---

多个父类有相同的属性或方法名,这种情况应该避免,会调用第一个父类方法。
总结 作为一门非常简便快速的语言,没有了;的限制,但是对缩进严格要求,课程不长,收获颇丰。

    推荐阅读