【Python全栈_公开课学习记录】

一、初识python

 (一).Python起源

Python创始人为吉多·范罗苏姆(荷兰),Python崇尚优美、清晰、简明的编辑风格。Python语言结构清晰简单、数据库丰富、运行成熟稳定,科学计算统计分析领先。目前广泛应用于云计算、Web开发、科学运算、人工智能、系统运维、金融领域。在金融领域中,主要用于量化分析、金融分析尤其擅长策略回测。机缘巧合通过视频课程学习Python,向金融+Python方向靠拢。

Python是一门解释性语言。区别于输出结果型,通过及时输出,提高开发效率。

(二).python的基本知识

1.python变量的命名规则

(1).python变量由字母、数字、下划线组成

(2). python变量不能用纯数字,也不能用数字开头

(3). python变量不能是python的关键字

2.python变量命名的常用规范

(1). 变量名不要太长

(2).变量名要有意义

(3)变量名区分大小写

(4).变量名不要用中文

(5).多使用驼峰体和下划线命名

3.python变量类型

(1).int类型,整数,可以进行+、-*、/、%(计算余数)、//(整除)运算

(2).str类型,字符串,',",'''。可以通过type(变量)查看数据类型,字符串可以进行+ *运算

(3).bool类型,真命题或假命题,结果True、False,只用来条件判断

(4).用户交互,使用input(),input接收到的为字符串

4.python基本数据类型

(1). int整数

#bit_length()返回一个数的二进制长度

(2)str字符串

由',",'''括起来的内容是字符串,字符串是不可改变的数据类型,不论执行任何操作,原字符串是不会改变的,每次操作都会返回字符串。

a.字符串的索引和切片

索引从0开始,使用[下标]

切片[起始位置:结束位置] #切片时顾头不顾尾,只能切到开头的位置,切不到结尾,默认从左往右切

print(s[-1:-3:-1])"-1"表示步长,每位移一单位,从右往左切片

b.字符串的修改

sn=s.capitalize() 把字符串首字母变成大写

sn=s.upper() 把字符串变成大写

sn=s.lower() 把字符串变成小写

sn=s.swapcase() 把字符串大小写互换

sn=s.title() 把字符串每个单词首字母变成大写

sn=s.center(x,"*or空白等") 把字符串左右两边用*拼接成x个单位

sn=s.strip() 默认去掉空格,空白,可以指定去掉的内容 (去掉左侧空格:s.lstrip 去掉右侧空格:s.rstrip)

sn=s.erplace("old","new") 把字符串中的内容进行替换

sn=s.split() 对字符串进行切割,切完的结果是一个列表 #与 joint相对

c.字符串的查找

sn=s.startwith() 字符串是否以xxx开头

sn=s.endwith() 字符串是否以xxx结尾

sn=s.count(a) 字符串中a出现的次数

sn=s.find(a) 查找字符串中a第一次出现的位置,没有返回-1

sn=s.inde(a) 查找字符串中a的位置,没有会报错

d.字符串的条件判断

s.isdigit() 判断是否为数字

s.isalpha() 判断是否为字母

s.isalnum() 判断是否为数字

e.字符串长度

len(s) 字符串中字符的个数 #python内置函数

(3)bool布尔值

布尔值只有两个值,True,False,空的东西是False,非空的是True

(4)list列表

a.什么是列表

列表是一个可变的数据类型,列表由[]表示,每一项元素用逗号隔开,列表什么都能装,能装对象的对象,列表可以装大量的数据

b.列表的索引和切片

列表和字符串一样,也有索引和切片,切片切出的内容是列表,索引的下标从0开始,[起始位置:结束位置:步长]

c.列表的增删改查

增加:lst.append() 在原有列表基础上进行的操作,屁股后面添加,只能加一个

lst.insert(n,xxx) 在第n个位置插入xxx

lst.extend(["",""]) 元素为列表整体添加,否则迭代添加

删除:lst.pop(n) 删除指定位置元素

lst.remove("") 删除特定元素

del lst[:] 切片删除

lst.clear() 清空

修改:lst[n]="xxx" 修改第n个元素为xxx

lst[m:n]=lst["x"] 切片部分修改为x

查询:for el in lst:

print(el)

d.列表的相关操作

计数:lst.count("") 列表中某个元素的个数

排序:lst.sort() 将列表正序排列

括号中加"reverse=True"变为降序排列

翻转:lst.reverse() 将列表中的元素翻转

嵌套:lst[][] 可进行降维操作

lst="_"join(["",""])将列表转换成字符串,每个元素之间用_连接

split字符串切割为列表

(5)tuple元组

元组tu用()表示,元组中如果只有一个元素,需要在括号中加入一个逗号,Tu=tuple()为空元组,元组是一个可迭代对象,可以使用for循环。

元组不可以进行增删改,只能看,可以查询,切片。

元组查询:tu[],tu[m:n]

元组第一层元素不能进行赋值,内部元素是没有要求的

(6)dict字典

a.字典的含义

字典dict用{}表示,字典为键值对数据,{key:value},具有唯一性特点

字典中的键都必须是可hash的,不可变的任何数据类型都可以当做字典中的键,字典中的值没有任何限制。

b.字典的增删改查

增加:dic[key]=value

dic.setdefault(key,value) 如果字典中不存在就进行添加,存在不做任何操作

删除:dic.pop("key")

del dic["key"]

修改:dic[key]=value 修改字典键对应的值

dic.update(字典)

查找:dic(key) 没有会报错

dic.get(key) 没有返回none

set.default(key)

c.字典的其他操作:

dic.keys 获取到的键存在一个高仿列表中

dic.values 获取到的值存在一个高仿列表中

dic.items 获取到的所有键值对元组形式存在一个高仿列表中

dic.fromkeys 不会对字典产生影响,fromkeys直接使用类名进行访问

列表和字典在循环的时候不能直接删除,需要把要删除的内容记录在新列表中,然后循环新列表进行删除。

(7)set集合

a.set集合定义:

set集合是Python的一个基本数据类型,一般不是很常用,set中的元素是不重复的,无序的,里面的元素必须是可hash的(int,str,tuple,bool),可以这样来记,set就是dict类型的数据,但是不保存value,只保存key,set也用{ }表示。

#set中的元素是可hash的,set本身不可hash.

集合去重

e9cd0a38092a4dc898e36e03c975d191.png822ac8ee40de4262931b4841a47dbf4b.png

b.set集合的增删改查

增加:s.add

s.update 迭代更新

删除: s.pop # 随机弹出一个

s.remove(“xxx”) #直接删除元素 元素不存在会报错

clear() 清空集合,打印出来是set()与dict区分

修改:

Set集合中的数据没有索引,也没有办法定位一个元素,所以没有办法直接修改,可以采用先删除后添加的方式完成修改操作

c.set集合的常用操作

查询:for 循环

交集:print(s1 & s2)

并集:  print(s1 | s2)

差集:print(s1 - s2)

子集:print(s1 <s2)

5.深浅拷贝

lst2 = lst1      # 赋值

没有创建新对象,共用同一对象。

7ea67e58411c45098462fec009716242.png
e5ee0e20b7554c8f9409dc04b516587e.png

lst2 = lst1[:]  #浅拷贝

只拷贝第一层内容: [:],copy()

b679e4074fb94fee92d30232683b8bff.png
c881c990138f4b8ea29951411527413d.png

深拷贝:把对象内部的内容全部拷贝一份,引入copy模块。

import copy

lst2 = copy.deepcopy(lst1)

6.文件操作

(1)初识文件操作

使用python读写文件是非常简单的操作,可以使用open()函数打开一个文件,获取到文件句柄,然后通过文件句柄就可以进行各种操作了,根据打开方式的不同能够执行的操作会有响应的差异。

文件操作的函数:

open(文件名(路径),mode="",encoding="")

ae4cb08a8e5a422eb1dab1cb8a49656d.png
f9ae3bad9b4547a9978929068d5f2f3d.png

文件路径

绝对路径: 从磁盘的根目录寻找或者从互联网上寻找一个路径。

相对路径:相对于当前程序所在的文件夹,../上一次文件夹。

(2)打开文件的方式:

r,w,a,r+,w+,a+,rb,wb,ab,r+b,w+b,a+b;默认使用的是r(只读)模式。

r模式

读取文件

for line in f:          #逐行读取

        print(line)

w模式

带w,只要操作,就会清空源文件。

如果没有文件,会自动创建文件。

b8dd9cc145c64e77bc467c22aa0e4e22.png

a模式

写的时候,换行需要手动控制,/n

f = open("hhh",mode="a",encoding="UTF-8")

b模式

rb、wb、ab、bytes如果处理非文本文件,不能写encoding

r+模式

不论读取了多少内容,光标在哪儿,写入的时候都是在结尾写入,除非开始就写入是在开头。

最好的读写同时存在的模式。

w+模式

写度会清空内容,写完之后光标在最后,读取是没有内容的。使用seek(0)移动光标到开头。

a+模式

追加不会清空,光标在最后,移动光标到开头。

(3)常用的操作

光标(seek)

seek(3)     #在开头移动3个byte

seek(0)#开头

seek(0,2)#末尾

tell() #光标位置

truncate() #从文件开头截断到光标位置,删除光标后面所有内容。

 (4)修改文件

引入os模块

打开目录文件

打开文件副本

从源文件中读取内容进行修改,写入到副本

删除源文件

重命名副本

497c395abb2a44a887c5a29da7d69a07.png

444d7792d24b4641a51b4409f724e34f.png

7.函数

(1)函数

函数是对功能的封装

语法:

def 函数名():

        函数体

调用:

函数名()

(2)返回值

如果函数什么都不写,不写return,没有返回值,得到的是none。

在函数中间或者末尾写return,返回none。

在函数中写return值,返回一个值。

在函数中可以返回多个返回值,return 值1,值2,值3...,接受的是元组。

978ef0ec8b3a40cc9d5ea9447e8ef0f5.png
ed9e4f37975e48ba8eb6a366be5b3409.png​​​​​​​

(3)参数

函数执行的时候给函数传递信息

在函数声明的位置的变量:形参

在函数调用的地方给的具体的值:实参

把实参的值交给形参的过程:传参

实参:

位置参数,按照形参的参数位置,给形参传值

关键字参数,按照形参的名字给形参传值

混合参数,既用位置参数,也用关键字参数,先位置,后关键字

形参:

位置参数

默认值参数

动态参数

*args,表示接受位置参数的动态传参,接受到的是元组。

顺序:位置参数>*args>默认值参数>**kwargs

**args,关键字的动态传参

(5)打散和聚合

形参:聚合

7117138c03824ddc9206bd76fc84f44f.png
66f931c0ab2a434c81f8a07a215fe934.png

实参:打散

0bdc95a50eab4cbfb7f5eee1b21affae.png

ca6518a033bc4232a60f06fe26e5aa51.png

func(*lst)  打散,把list,tupple,set,str进行迭代打散

聚合成关键字参数:

def func(**kwargs):

        print(kwargs)

打散成关键字参数:

dic = {'a':'1','b':'2'}

func(**dic)

(6)函数的注释:

97e1b69f021a4e8391dfadd3fdd03858.png​​​​​​​

(7)命名空间

        在python解释器开始执行之后,会在内存中开辟一个空间,每当遇到一个变量的时候,就把变量名和值之间的关系记录下来,但是当遇到函数定义的时候,解释器只是把函数名读入内存,表示这个函数存在了,至于函数内部的变量和逻辑,解释器是不关心的。函数只是加载进来,只有当函数被调用和访问的时候,解释器才会根据函数内部声明的变量来进行开辟变量的内部空间,随着函数执行完毕,这些函数内部变量占用的空间也会随着函数执行完毕而被清空。

        我们给存放名字和值的关系的空间起名叫:命名空间。变量在存储的时候就是存储在这片空间中。

        命名空间分类:

        1.全局命名空间:直接在python文件中,函数外声明的变量都属于全局命名空间

        2.局部命名空间:在函数声明的变量会放在局部命名空间

        3.内置命名空间:存放python解释器提供的名字,list,tupple,str,int,这些都是内置命名空间。

       加载顺序:内置命名空间-全局命名空间-局部命名空间(函数被执行的时候)

        取值顺序:局部命名空间-全局命名空间-内置命名空间

作用域:作用域就是作用范围,按照生效范围分为 全局作用域和局部作用域

全局作用域:包含内置命名空间和全局命名空间。在整个文件的任何位置都可以使用。(从上到下逐行执行)

局部作用域:在函数内部可以使用。

可以通过globals()函数查看全局作用域中的内容,也可以通过locals()查看当前局部作用域中的变量和函数信息。

(8)global和nonlocal

global:在局部访问全局中的内容

nonlocal:在局部寻找外层函数中最近的变量

(9)函数名的应用

函数名的命名规范和变量是一样的,函数名就是变量名。

函数名可以作为列表中的元素进行存储。

def func1():

        pass

def func2():

        pass

lst = [func1,func2]

for el in lst:

        el()

函数名可以作为参数传递给函数:

def func():

        pass

def proxy(fn):

        fn

proxy(func)

函数名可以作为函数的返回值:

def func():

        def inner():

                pass

        return inner   #返回内存地址

(10)闭包

闭包:在内层函数中访问外层函数的变量

闭包的作用:

        1.可以保护变量不受侵害

        2.可以让一个变量常驻内存

判断是否是是闭包:

def func():

        a=10

        def inner()

                print(a)

        print(inner.__closure__) #如果打印none,不是闭包;如果不是none,是闭包。

8.迭代器

用来遍历列表、字符、元组... 可迭代对象。

dir(),查看xx类型的数据可以执行哪些方法。

iterable,其中带__iter__,可以使用for循环,为可迭代对象。

iterator,迭代器里有__iter__,还有__next__。

dir(int)

0a8d2d73ef7c468f9e6b60a1b365bbc8.png

dir(str)

f4dfdfb5be6546fb96340e0b6a88b93f.png

迭代器的特点:

        节省内存

        惰性机制

        不能反复,只能向下执行

9.生成器

函数中如果有yield,这个函数就是生成器函数,生成器函数(),获取的是生成器,这个时候不执行函数。

yield:相当于return,可以返回数据,但是yield不会彻底中断函数,分段执行函数。

gen.__next__(),执行函数,执行到下一个yield。

def func():

        print("")

        yield 1        #返回数据

gen = func()     #不会执行函数,拿到的是生成器

send(),和__next__()一样,可以执行下一个yield,可以给上一个yield位置传值。

send 和 __next__()区别:

        send 和 __next__()都是让生成器向下走一次

        send可以给上一个yield的位置传递值,不能给最后一个yield发送值。在第一次执行生成器代码的时候不能使用send()。

10.推导式

推导式:用一句话生成一个列表。

语法:[结果 for 循环 条件筛选]

列表推导式

lst = [i for i in range(100) if i%2==1]

print(lst)

字典推导式:{k:v for 循环 条件筛选}

lst = [11,22,33,44]

dic = { i:lst[i] for i in range(lst)}

print(dic)

生成器表达式:

(结果 for循环 条件)

特点:

        惰性机制

        只能向前

        节省内存

11.内置函数

7b90df71d5fd4e9199d75c43fe8d1c36.png

作用域:globals,locals

迭代器:iter,next,range

其他:

        输入输出:input,print

        内存相关:id,hash  (目的是为了存储,计算之后是一个数字,拿空间换时间)

        文件相关:open       

         模块相关:import   

         帮助:help 

         调用相关:callable         #是否可以被调用执行

         查看内置属性:dir      

        字符串类型执行代码函数:eval(动态执行代码片段,还原回字典、列表),exec(执行),compile(编译)

基础数据类型相关:

        数字相关:

                数据类型:bool,int,float,complex

                进值转换:bin 二进制

                                     oct 八进制

                                     hex 十六进制​​​​​​​

                数学运算:abs             绝对值

                                     divmod     计算商和余数

                                     round         四舍五入

                                     pow            求次幂,第三个参数取余

                                  sum            求和

                                    min              最小值

                                    max             最大值

        数据结构相关:

                列表和元组:list,tupple

                序列相关内置函数:reversed(翻转),slice(切片)

                字符串:str,format(格式化),bytes,bytearry,memoryview,ord(查看编码位置),chr(输入位置数字找出对应字符),ascii,repr(原样输出字符串)。

                数据集合:dict,set,frozenset

                 数据相关内置函数:len,sorted,enumerate,all,any,zip,fiter,map

匿名函数:lambda()

        匿名函数(单行函数),语法:lambda 参数: 返回值

a = lanbdan : n*n

ret = a(9)

print(ret)

排序函数:sorted()

sorted()

list = ['西游记',‘水浒传’,‘三国演义’,‘红楼梦’]

def  func(s)

        return len(s)

n = sorted(lst, key=func)

print(n)

​​​​​​​

#key:排序方案,sorted函数内部会把可迭代对象中的每一个元素拿出来交给key,后面的key计算出数字,作为当前元素的权重,整个函数根据权重进行排序。

过滤函数:filter()

lst = ['唐三藏',‘孙悟空’,’猪八戒‘,’沙悟净‘]

def func(el):

        if el[0] == ’猪‘

                return False   #不想要的元素

        else:

                return Ture   #想要的元素

f = filter(func,lst) #将lst中每一项传递给func,所有返回Ture的都会被保留,返回False的过                                                    滤

f = filter(lambda el:el[0] 1= '猪',list)

for e in f:

        print(e)

映射函数:map()

 map(func,lst) 把后面可迭代对象的每个元素传递给function,结果就是function的返回值。

分而治之思想

map(func,map(func,map(func,lst)))

递归函数:

自己调用自己。

递归深度,可以自己调用自己的次数,最大1000。

遍历文件夹:打印所有文件和普通文件的文件名

import os 

def func(filepath,n):

        # 打开文件夹

        files = os.listdir(filepath)

        # 拿每一个文件名

        for file in files:

                #获取文件路径

                file_path = os.path.join(filepath,file)

                判断是否是文件夹

                if os.path.isdir(file_path):

                        # 如果是文件夹,继续再来一遍

                        print("\t"*n,file,":") #打印文件名

                        func(file_path,n+1)

                else:       #不是文件夹,普通文件

                         print("\t"*n,file)       

                        

func("d:/",0)

二分法:

二分法可以在有序排列中,通过不断对半切割数据,提高数据查找效率。

lst = [1,4,6,7,45,66,345,767,788,999]

n = 66

left = 0

right = len(lst)-1

while left < right:     #边界,当右边比左边还小的时候退出循环

        mid = (left + right)//2    #必须是整数,索引没有小数     

        if lst[mid] > n:           

                right = mid - 1      

        if lst[mid] < n:             

                left = mid +1      

        if lst[mid] == n:              

                print("找到这个数")             

        break     

        else:           

                print("没有这个数")

递归二分法

lst = [11, 23, 45, 67, 99]

def func(n,left,right):      

        if left <= right:            

                mid = (left +right)//2                

                if n > lst[mid]:                     

                        left = mid +1                      

                        func(n,left,right)  #递归 递归入口               

                if n < lst[mid]:                        

                        right = mid -1                   

                        func(n,left,right)               

                if n == lst[mid]:                   

                         print("找到了这个数")               

                else:                       

                        print("没有这个数")   #递归的出口

12.常用模块

re模块

查找:

findall:  匹配所有,每一项都是列表中的一个元素

ret=re.findall('\d+','sasff454feaf')    #正则表达式,待匹配的字符串

print(ret)

search: 只匹配从左到右第一个,得到的不是直接的结果,而是一个变量,通过变量的group方                                     法获取结果。如果没有匹配到,会返回none,使用group会报错。

ret = re.search('\d+','sdfsadga654fhhd656')

print(ret)  #内存地址,这是一个正则匹配的结果

print(ret.group())    #通过ret.group()获取真正的结果


防止报错

ret=re.search('\d+','dsdaasfgds')

if ret:

        print(ret.group())

match:  从头开始匹配,相当于search中的正则表达式加上^

字符串处理的扩展:替换、切割

split: 切割返回列表,按照正则规则切割,默认匹配到的内容会被切掉

s = 'alex43bob4434david4'

ret = re.split('\d+',s)

print(ret)


sub: 替换  #对象、旧的、新的、替换次数,按照规则寻找要被替换掉的内容

re.sub('\d+', 'H', 'alex4354bob43david4',1)

print(ret)


subn: 返回一个元组,第二个元素是替换的次数


re模块的进阶:时间/空间

compile 节省使用正则表达式解决问题的时间,编译正则表达式为字节码,在多次使用的过程中,不会多次编译。用正则表达式进行findall,search...能够节省时间

ret = re.compile('\d+')

print(ret)

res = ret.findall('alex24bob4352david42')

finditer 返回一个迭代器,所有的结果都在迭代器中,需要通过循环+迭代器的形式取值,能节省使用正则表达式解决问题的空间

ret = re.finditer('\d+','alex42bob8878david99')

for i in ret:

        print(i.group())

正则表达式:   参考书《正则指引》

普通字符就表示一个正常的字符,元字符表示特殊的意义,如果转义元字符,那么这个元字符就失去了特殊意义。

几个字符的组合关系:

        字符/元字符:只约束一个字符

        字符+量词:约束一个字符连续出现的次数

        字符+量词+?:约束一个字符连续出现量词范围内的最少次数

        字符+量词+?+x:约束一个字符连续出现量词范围内的最少次数,遇到x立即停止

元字符:\d, \w, \s, \n, \t, \b, \W,  \D, \S    .  ^$ []  [^]   |    ()

量词:?  +   *   {n}  {n,}    {n,m}

贪婪匹配:默认贪婪匹配

分组在模块中的应用:

search中分组:

import re

s = <a>wahaha</a>  #标签语言

ret = re.search('<(\w+)>(\w+)</(\w+)>',s)

print(ret.group(0))   #显示所有

print(ret.group(1))   #显示第一个分组

print(ret.group(2))  #显示第二个分组

print(ret.group(3))   #显示第三个分组

分组命名: (?p<这个分组的名字> 正则表达式)

random模块

获取随机小数


获取随机整数

从一个列表中随机抽取值


sample不会取到重复值。

打乱一个列表的顺序:在原列表的基础上进行修改,节省空间


time模块

time模块主要和时间相关

time.sleep()     #程序走到这等待2s钟

时间格式:

时间戳:时间戳表示的是1970年1月1日00:00:00开始按秒计算的偏移量,运行type(time.time()) ,返回float浮点数类型​​​​​​​。

格式化时间字符串:2023-01-01

        print(time.strftime('%Y-%m-%d %H-%M-%S'))

        print(time.strftime(%y-%m-%d %H-%M-%S))

        print(time.strftime('%c'))  #国外时间格式


结构化时间(元组):

        time.localtime()


​​​​​​​

三种时间格式的转换:

时间戳时间转换成字符串时间:


字符串时间转换成时间戳:

sys模块:

        和python解释器打交道

sys.argv  #argv 的第一个参数,是python这个命令后面的值

        当在命令行执行python文件,不是pycharm中,这些需要输入的参数不需要在程序中以input的形式输入了。

sys.path  #模块存在硬盘上,使用的时候才在内存中。一个模块能否顺利导入,看sys.path下面有无这个模块所在。

sys.modules  #是我们导入内存中的所有模块的名字:这个模块的内存地址

​​​​​​​

os模块:

        和操作系统交互的模块。

序列化模块:

        将列表、字典等其他内容转换成字符串和bytes的过程就是序列化。


序列化的目的:

以某种存储形式使自定义对象持久化

将对象从一个地方传递到另一地方

使程序更具维护性

json模块:

dumps,loads 在内存中做数据转换

json.dumps()    序列化

json.loads()      反序列化

json 在所有的语言之间都通用

json 能处理的数据类型是有限的:字符串 列表 字典 数字

字典中的key只能是字符串

在文件中记录字典:

在文件中读取字典:

dump, load可以直接操作文件

dic = {'key1':'value','key2':'value2'}

with open('json_file','a') as f:

        json.dump(dic,f)

with open('json_file','r') as f:

        dic = json.load(f)

print(dic.keys())

pickle模块:

支持python中几乎所有的数据类型

序列化的结果只能是字节

只能在python中使用

和文件操作的时候需要用rb,wb模式打开

可以多次dump和load

异常处理:

python解释器检测到错误,触发异常。程序员编写特定的代码,专门用来捕捉这个异常,如果捕捉成功则进入另外一个处理分支,执行为其定制的逻辑,使程序不会崩溃。


单分支:

try:

        ...

except ValueError:   #except处理的异常必须和实际报错的异常相同

多分支:

try:

        ...

        ...

except ValueError:  #从上到下找到与报错相符的分支就执行代码,然后直接退出分支

        ...

except IndexError:  #如果找不到处理和报错类型相同的分支,一直往下走,最后没有保错

        ...

多分支合并:

try:

        ...

except (ValueError,IndexError):

        print('输入内容不合法')

万能异常:

try:

        ...

except Exception:

        ...


​​​​​​​

多分支和万能异常可以结合使用,万能异常在最后处理。


​​​​​​​

else分支:当try中的代码不发生异常的时候执行。

finally:无论如何都会被执行。  # f.close()

try...except

try...except...else

try...finally

try...except...finally

try...except...else...finally

主动抛异常:raise ValueError, 主要给其他开发者用。

断言:assert  1==2 只接受布尔值。

模块导入:

模块:已经写好的一组功能的集合。写好的函数、变量、方法放在一个文件夹,这个文件就是一个模块。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值