python基础复习
python基础复习
一、变量与常量
-
变量的定义与使用
变量值 = 变量名
-
变量的命名规则
- 1、数字、字母、下划线的组合
- 2、不能以数字开头
- 3、不能重名关键字
-
变量命名类型
- 大驼峰命名法（类）
- 小驼峰命名法
- 下划线命名法（方法）
-
变量值的三大特性
- id()：变量值在内存中的内存地址
- type()：变量值的数据类型
- value：变量值本身
-
常量的定义
- 在python中并没有明确规定常量的定义语法
- 我们一般使用变量名全大写，作为常量名
- 常量即在整个项目运行过程中都不会发生改变的值，例如：HTTP状态码
PI = 3.14..
二、数据类型
-
number数字类型
-
数据类型分为
- int(number/unicode, base=10)：整型
- float(number)：浮点型
- complex(number)：复数
-
进制转换
- bin(number)：转换为二进制
- oct(number)：转换为八进制
- hex(number)：转换为十六进制
-
-
string字符串类型
字符串类型的定义: 使用单引号、双引号、三引号，将对象括起的，就是字符串-
判断
- startswith(str, start, end)：判断str是否为指定范围字符串中第一个字符
- endswith(str, start, end)：判断str是否为指定范围字符串中最后一个字符
- isalpha()：判断字符串是否为纯字母组合
- isalnum()：判断字符串是否为字母、数字组合
- isupper()：判断字符串是否为纯大写字母
- islower()：判断字符串是否为纯小写字母
- istitle()：判断字符串是否为每个单词首字母均大写，且其他字符均小写
- isdigit()：判断字符串是否为bytes、unicode组合
- isdecimal()：判断字符串是否为纯unicode编码值
- isnumeric()：判断字符串是否为unicode、中文、罗马数字组合
- isspace()：判断字符串是否为纯空白字符组合
-
修改
因为字符串类型为不可变数据类型，所以对其的所有修改操作，都会返回一个修改后的结果，而不会修改原字符串- replace(old, new, count=None)：使用new字符替换old字符，count指定次数，默认全部替换
- ljust(width, chars=None)：指定字符串宽度（字符串超出无影响），字符串宽度小于width时，使用chars指定的字符来在字符串右侧填充
- rjust(width, chars=None)：指定字符串宽度（字符串超出无影响），字符串宽度小于width时，使用chars指定的字符来在字符串左侧填充
- center(width, chars=None)：指定字符串宽度（字符串超出无影响），字符串宽度小于width时，使用chars指定的字符来在字符串两侧填充
- zfill(width)：指定字符串宽度（字符串超出无影响），字符串宽度小于width时，使用数字0来在字符串两侧填充
- strip(chars=None)：去除字符串两侧重复的chars字符，不指定则默认去除空白字符
- rstrip(chars=None)：去除字符串右侧重复的chars字符，不指定则默认去除空白字符
- lstrip(chars=None)：去除字符串左侧重复的chars字符，不指定则默认去除空白字符
- lower()：将字母全小写
- upper()：将字母全大写
- title()：将单词首字母全大写，单词内字母均小写
- 'str'.join(iterable)：将可迭代对象使用str字符拼接，返回拼接后的字符串
- expandtabs(tabsize=8)：指定字符串中\t的空格数，python中默认一个\t四个空格
-
查找
- len(str)：获取字符串中字符个数
- str[index]：获取字符串中指定index字符
- str[start: end: step]：获取字符串中指定区间字符
- find(sub, start, end)：在限定范围内，获取第一个sub字符所在下标，如果不存在则返回-1
- rfind(sub, start, end)：在限定范围内，获取最后一个sub字符所在下标，如果不存在则返回-1
- index(sub, start, end)：在限定范围内，获取第一个sub字符所在下标，如果不存在则抛出异常
- rindex(sub, start, end)：在限定范围内，获取最后一个sub字符所在下标，如果不存在则抛出异常
- count(sub, start, end)：计算指定范围内，sub字符出现的次数
- split(sub, maxspilt=-1)：将字符串中，sub字符作为分隔符，返回一个列表，maxspilt指定分隔次数，-1代表无限大
- rsplit(sub, maxspilt=-1)：将字符串中，sub字符作为分隔符，反向分隔，返回一个列表，maxspilt指定分隔次数，-1代表无限大
- partition(sub)：将字符串以sub字符为根，分隔为(sub字符前, sub, sub字符后)，返回一个元组
- rpartition(sub)：将字符串以sub字符为根，反向分隔为(sub字符前, sub, sub字符后)，返回一个元组
- splitlines(keepends=False)：以字符串中\n为分隔符，返回一个列表，keepends指定是否保留\n，False为不保留
-
转移字符
在原生字符前加\，就会将该字符转换为其他功能 \\ \' \'' \f \t \n \v \r r'' R'' 在字符串前加r/R，可以阻止其内部转移功能，只能输出原生字符串 -
格式化字符串
-
format()
{} 'zzw{}, ceshi{}, hehe{}'.format(1, 2, 3) # 'zzw1, ceshi2, hehe3' {int} 'zzw{1}, ceshi{3}, hehe{2}'.format('a', 'b', 'c') # 'zzwa, ceshc, heheb' {命名关键字} 'zzw{name}, ceshi{age}, hehe{height}'.format(age=14, height=13, name=12) 'zzw12, ceshi14, height13' -
%
%s 通用的占位符 %d 数字的占位符 %nd n限定数字长度，不足使用空格在数字前面补全 %-nd n限定数字长度，不足使用空格在数字后面补全 %'str'nd n限定数字长度，不足使用'str'在数字前面补全 %f 浮点数的占位符 %.nf .n限定浮点数的小数位数（保留多少小数位） %x 数字的占位符，输出时，将数字转换为小写16进制 %X 数字的占位符，输出时，将数字转换为大写16进制 %% 输出%
-
-
-
boolean布尔类型
-
False/True
-
bool(obj)：将obj转换为bool类型
- False：空字符串、空字典、空集合、空列表、空元组、0、None、False、
-
-
list列表类型
-
增加
- append(obj)：将obj添加到列表末尾
- insert(index, obj)：将obj添加到列表index前
- extend(iterable)：将iterable中的元素遍历添加到列表末尾
-
删除
- clear()：删除列表
- remove(value)：删除列表中value值，返回None
- pop(index)：删除列表中index的值，并返回value
- del list：删除变量与列表的引用
-
修改
- list[index] = value
-
查询
- len(list)：获取列表中元素个数
- index(value, start, end)：指定范围，value对应的index
- obj in/not in list：判断obj是否存在list中，返回bool
- count(value)：计算value在list出现次数
-
排序
- [::-1]：反向排序
- reverse()：反向排序
- sort(key=func, reverse=False/True)：将列表由大到小排序，reverse=True代表排序完后，再反向排序。key代表当元素存在字典时，指定字典中进行比较的值
- sorted(iterable, key, reverse)：与sort基本一致，区别在于sorted不会改变原有列表，而是生成新列表
-
列表推导式
- [i for i in range(1, 10) if i % 2 == 0]
- [(x, y) for x in range(1, 10) for y in range(20, 30)]
-
-
tuple元组类型
-
查询
- len(tuple)：获取元组元素个数
- in/not in：判断对象是否存在元组中，返回bool
- index(value, start, end)：获取value在元组中下标
- count(value)：返回value出现次数
- 下标/切片方式
-
增加
- tuple1 + tuple2：将tuple2中的元素逐个添加到tuple1的末尾，将执行结果返回一个新元组，不会修改原元组
-
-
set集合类型
-
集合特点
-
不可重复性
-
无序性
- 如果集合内所有元素均是number类型，那么会自动从小到大排序
-
集合内元素必须为不可变数据类型
-
-
增加
- add('不可变数据类型')：将数据添加到集合随机位置
- union(iterable)：将iterable中的元素跌打添加到集合随机位置，并将执行结果返回一个新集合，对原集合不会修改
- update(iterable)：将iterable中的元素跌打添加到集合随机位置，修改原集合
-
删除
- clear()：删除集合
- pop()：随机删除集合中一个元素，并返回元素值
- remove(element)：删除集合中指定元素
- del set：取消变量名与集合的引用关系
-
查看
- len(set)：获取元素个数
-
集合与运算符
以下操作并不会修改原集合- set1 - set2：去交集，将set1中与set2重复的部分去除
- set1 & set2：交集，返回set1与set2重复的部分
- set1 | set2：并集，返回set1与set2合并
- set1 ^ set2：差集，返回set1与set2不重复部分的合并
- set1 >/>= set2：判断set1是否为set2父集，返回bool
- set1 </<= set2：判断set1是否为set2子集，返回bool
-
-
dictionary字典类型
字典的key必须为不可变数据类型 字典的value可以是任何数据类型 如果key重复，则后面覆盖前面-
增加
- dict[key] = value：增加k-v
- update(dict)：将dict中的k-v均添加到当前dict中
- fromkeys([key1, key2, ...], value)：清除dict中所有k-v，并设置k1...的value均为value
- setdefault(key, defalut=None)：如果key存在，则返回value值，如果不存在则创建，使用default作为value
-
删除
- del dict：取消引用
- clear()：删除字典
- popitem()：随机删除一对k-v，以元组形式返回
- pop(key, default=None)：key存在，则删除，返回value，key不存在，则返回default值
-
修改
- dict[key] = value
-
查找
- len()：获取字典中key个数
- in/not in：判断object是否是字典中某个key
- get(key, default=None)：获取key对应的value，如果不存在则使用default值作为返回值
- keys()：返回dict_keys([所有key])
- values()：返回dict_values([所有value])
- items()：返回dict_items([(k,v),....])
-
-
通用方法
-
内置函数
- str(obj)
- bool(obj)
- len(obj)
- set(iterable)
- list(iterable)
- tuple(iterable)
- dict(**kwargs, zip)
- enumerate(iterable)
-
算术运算符
- +：tuple、number、string、list
- -：set
- *：number、string、list、tuple
- in/not in：string、list、tuple、set、dictionary
-
三、字符串编码
'''
ASCII --> Latin1 --> Unicode
1. 计算机只能够识别机器语言，即0/1，为了实现人类常用语与机器语言的对应关系，方便存取数据
2. 早期设计了一种数字、字母、符号与二进制的对应关系表，即ASCII码表。ASCII编码表使用7位二进制表示一个字符，它的区间范围是0-127，一共只能表示128个字符，仅能支持英语。
3. 随着计算机科学的发展，西欧语言、希腊语、泰语、阿拉伯语、希伯来语等语言的字符也被添加到码表中，形成了一个新的码表ISO8859-1（又被称之为Latin1码表）。ISO8859-1使用8位二进制表示一个字符串，完全兼容ASCII码表
4. 到如今的时代，在Latin1码表的基础上再次延申发展出了统一的编码规则：Unicode
Unicode（统一码、万国码、单一码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等
Unicode是为了解决传统的字符编码方案的局限而产生的，它为每种语言的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。
'''
chr(编码值) ---> 返回编码值在unicode中对应的字符
ord(字符) ---> 返回字符在unicode中对应的编码值
'''
使用Unicode为每种语言的每个字符都设定了唯一的二进制编码，但是他还是会存在一定的问题，不够完美。
例如：汉字"你"转换成一个字符结果就是`0x4f60`,转换成二进制就是`01001111 01100000`,此时就出现两个问题：
1. `01001111 01100000`到底是一个汉字'你'，还是两个Latin1字符？
2. 如果Unicode进行了规定，每个字符都使用n个八位来表示，对于Latin1字符来说，又会浪费很多的存储空间
为了解决这个问题，就出现了一些编码规则，按照一定的编码规则对Unicode数字进行计算，得出新的编码。在中国常用的字符编码有`GBK`,`Big5`和`utf8`这三种编码规则：
GBK：国标扩，汉字占两个字节，简体中文
Big5：繁体中文
utf-8：统一编码，汉字占三个字节
'''
encode('编码规则') ---> 将字符串按照'编码规则'进行编码成bytes
decode('编码规则') ---> 将编码后的bytes按照'编码规则'进行解码
bytes('str', encoding='编码规则') ---> 将str字符串按照encoding编码规则进行编码，并返回bytes类型的数据
四、垃圾回收机制GC
1、垃圾回收前置知识
'''
内存相关：
堆区：直接存放变量值数据本身
栈区：存放变量名与变量值内存地址关系
直接引用：从栈区出来，直接能够获取到变量值
间接引用：从堆区出来，还需要继续跳转才能获取到变量值
'''
2、垃圾回收机制原理
'''
解释器在执行到定义变量的语法时，会申请内存空间来存放变量值，而内存容量是有限的
但从逻辑层面分析，我们定义变量的作用就是为了后续调用变量名去取出变量值，而变量名是通过直接引用/间接引用的关系来关联变量值的，如果一个变量值不存在任何直接引用/间接引用关系，那么他就应该被回收内存空间
垃圾回收机制GC是Cpython解析器提供的自动的垃圾回收机制，专门用来回收不可用的变量值所占用的内存空间
python的GC模块主要运用了以下：
引用计数：来跟踪和回收垃圾
标记-清除：在引用计数的基础上，可以通过标记清除来解决循环引用问题
分代回收：通过分代回收来以空间换取时间的方式来提高垃圾回收的效率。
'''
-
引用计数
- 当一个变量值被直接/间接引用，则引用计数+1
- 当一个变量值得引用计数为0时，那么它所占内存空间就应该被回收
-
循环引用问题
- 引用计数机制存在着一个致命的弱点，即循环引用（也称交叉引用）
- 当我们使用容器类型来互相引用时，即便清除了变量名与容器之间的引用关系，但容器与容器之间依然存在引用，从而导致引用计数不为0，无法被回收
- 在这种情况下，我们需要标记-清除来解决循环引用问题
-
效率问题
- 基于引用计数的回收机制，每次回收内存，都需要把所有对象的引用计数都遍历一遍，这是非常消耗时间的，于是引入了分代回收来提高回收效率，分代回收采用的是用“空间换时间”的策略。
-
标记-清除
-
当应用程序可用的内存空间被耗尽的时，就会停止整个程序，然后进行两项工作，第一项则是标记，第二项则是清除
- 标记：标记的过程其实就是，遍历所有的GC Roots对象(栈区中的所有内容或者线程都可以作为GC Roots对象），然后将所有GC Roots的对象可以直接或间接访问到的对象标记为存活的对象，其余的均为非存活对象，应该被清除。
- 清除：清除的过程将遍历堆中所有的对象，将没有标记的对象全部清除掉。
-
-
分代回收
- 分代：分代回收的核心思想是：在历经多次扫描的情况下，都没有被回收的变量，gc机制就会认为，该变量是常用变量，gc对其扫描的频率会降低
- 回收依然是使用引用计数作为回收的依据
'''
解释器在执行到定义变量的语法时，会申请内存空间来存放变量值，而内存的容量是有限的
从逻辑层面上将，我们定义一个变量的作用就是为了后续的调用，而调用变量名就是调用它的直接/间接引用关系来获取内存中存储的变量值，对于一个变量值，如果不存在直接/间接引用关系，那么它就因该被当作垃圾回收
GC机制是Cpython解释器的特性，可以自动的帮助我们回收内存中的不再使用的变量值的内存空间（垃圾）
GC机制主要通过以下三个方面进行：
引用计数：
对于变量值，如果存在直接/间接引用关系，那么引用计数+1
对于引用计数为0的变量值，我们应该回收它的内存空间
循环引用问题：（交叉引用）
对于容器类型，它内部存放对于变量值的间接引用
如果两个容器类型交叉间接引用对方的内存地址
那么，即使清楚了他们所关联的直接引用，依然存在容器之间的间接引用关系
从而引用计数无法归0，一直占用内存空间
标记-清除：
当内存空间被占满时，立刻停止当前进程，执行以下两个步骤
标记：遍历所有栈区中的对象，对于栈区中能够直接/间接引用的变量值，标记为存活
清除：遍历所有堆区中的对象，对于堆区中没有标记存活的变量值，回收其内存空间
效率问题：
我们在运行一个程序时，不可能都等到它内存空间占满时再执行标记清除动作
但又不能频繁的遍历堆区、栈区中的对象，从而浪费计算机资源
在此情况下，出现了分代回收概念
分代回收：
分代：对于多次遍历下，依然存活的变量值，我们将其划为下一代，减少其遍历频率
回收：正常回收机制
'''
五、可变数据类型/不可变数据类
什么是可变数据类型？
set、list、dictionary
修改变量值，则内存地址不会发生改变的
什么是不可变数据类型？
number、string、tuple
修改变量值，内存地址会发生改变
对于两个不可变数据类型，他们的变量值完全一样，则代表他们指向同一块内存地址
六、深/浅复制
什么是深复制？
对于容器类型，它内部往往存放的元素有可能是间接引用，尤其是对于容器类型之间的嵌套
对于此情况，我们在复制一个容器类型时，往往只能复制其外层嵌套，对于内层嵌套的容器只能复制其内存地址，而不是数据本身
可以使用copy模块中的deepcopy来实现深复制
import copy
copy.deepcopy(obj)
什么是浅复制？
对于复制一个对象，没有完全将其源数据复制一份，而是有可能复制了其内部数据的内存地址
对于此情况，当修改源数据时，我们复制的数据也会发生改变，这是及其不利的
可以使用.copy 和 copy模块中的copy实现浅复制
import copy
copy.copy(obj)
obj.copy()
七、输入输出语句
print()输入语句
print(obj, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
'''
obj：填入的需要输出的对象，可以是多个，需要使用逗号分隔
sep：多个对象之间的分隔符号，默认空格
end：print语句结束符，默认\n
file：print语句输出位置，默认sys.stdout，即终端命令行，可以设置为open对象
flush：设置是否缓存，默认False，该参数只有在file是open文件时才有效，如果设置为True，则文件传输到一半会断流
'''
input()输出语句
input('提示信息')
在终端命令行显示 '提示信息':
在输入了数据后，按回车生效
八、基本运算符
-
算术运算符
+ - * / % // ** () -
比较运算符
> >= < <= != == -
赋值运算符
# 将左侧的内存地址赋值给右侧 = # 增量赋值 -= += *= /= %= **= //= # 链式赋值 a=b=c=10 # 解压赋值 a, b = [1, 2] a, *b = [1, 2, 3, 4] # 交叉赋值 a, b = b, a -
逻辑运算符
not 逻辑非 and 逻辑与 or 逻辑或 逻辑运算符的短路问题： 一旦有结果，则直接返回结果，不会继续比较 逻辑运算符的优先级： not > and > or -
成员运算符
in # obj1 in obj2 判断哦obj1是否是obj2对象的成员，返回bool值 not in -
身份运算符
is # obj1 is obj2 判断obj1关联的内存地址是否与obj2关联的内存地址一致，返回bool值 is not -
位运算符
& 按位与，都为1才为1 ''' '0b111110' --> 62 '0b011110' --> 30 '0b011110' --> 30 ''' | 按位或，有1则为1 #0b111110 --> 62 ^ 按位异或，不同则为1 #0b100000 --> 32 ~ 按位取反，-x-1 #~30 --> -31 #-0b11111 --> -x-1 << 左移 #30 << 3 --> 240 --> '0b11110000' >> 右移 #30 >> 3 --> 3 --> '0b11'九、流程控制
-
分支结构
-
if ... else
if 13 > 14: # 放入条件判断 pass else: pass -
if ... elif .. else
if not 13 and 14: pass elif 14 > 13: pass else: pass -
if语句存在区间判断
-
if语句存在隐式类型转换
-
if语句三元表达式
a = 10 if 10 > 11 else 11 # a = 11
-
-
循环结构
-
for
for i in range(1, 10): # 放入可迭代对象 pass for i in range(1, 10): pass else: # for循环正常执行完毕后执行的语句 pass -
while
while True: pass while True: pass else: # while循环正常执行完毕后执行的语句 pass
-
-
break/continue/pass关键字
break：直接终结当前循环，且不执行后续else语句 continue：跳过本次循环 pass：占位，无任何意义
-
九、文件处理
-
打开文件
open('文件路径', mode='打开模式', encoding='编码格式') ''' 我们需要了解，文件它是存储在磁盘中，以二进制形式存放的，当我们需要获取一个文件数据时 首先需要将磁盘中文件数据加载到内存 然后内存以特定的编码格式（默认以当前系统编码格式）编码 将编码后的数据加载到程序/进程中 文件路径： 绝对路径：直接填写完整的根目录 C:\\xxx\\xxx\\... 相对路径：以当前py文件所处目录为根 ./当前目录 ../上一级 mode： r：只读模式 w：只写模式 1. 当我们使用w模式打开一个已存在文件时，会自动清空文件内容 2. 当我们使用w模式打开一个不存在文件时，会自动创建文件 a：追加写模式 1. 追加写模式不会清除文件内容，而是会在末尾换行增加数据 t：文本打开（默认） b：二进制打开 1. 在b模式下无需添加encoding参数 +：合并模式 U：通用换行模式（不推荐） encoding： windows:GBK linux:UTF-8 需要注意：打开文件与写入文件的编码格式需要一致 ''' -
读取数据
-
read()/readline()/readlines()
f = open('', mode='r', encoding='utf8') f.read(1024) # 读取文件内所有内容，返回字符串 f.readline(1024) # 读取文件内当前光标所在行的内容，返回字符串 f.readlines(1024) # 读取文件内所有内容，返回列表，一行代表一个元素 ''' 如果rt：1024代表取出的字符数 如果rb：1024代表取出的字节数 '''
-
-
写入数据
-
write()
f = open('', mode='w', encoding='utf8') f.write(str/bytes) ''' 如果wt：则直接写入字符串即可，内部会进行自动按照encoding进行编码，如果不给定encoding参数，则默认使用当前系统的编码格式 如果wb：则直接写入编码后的二进制即可 '''
-
-
控制游标
-
seek(offset, 0/1/2)
f = open('', mode='r', encoding='utf8') f.seek(offset, 0/1/2) ''' offset: 偏移量，单位字节 0：默认模式，以文件开头作为参照 以下两个方式需要rb模式下，才能使用 1：以当前光标所在，作为参照 2：以文件末尾作为参照 ''' -
tell()
f = open('', mode='r', encoding='utf8') f.tell() # 获取当前光标距离文件首位的字节数
-
-
关闭文件
-
close()
f = open('', mode='r', encoding='utf8') f.close()
-
-
with关键字
with关键字可以实现自动关闭文件操作 with open('', mode='r', encoding='utf8') as f: f.xxx
十、函数基础
-
函数的基本语法
def 函数名(): ''' 方法描述 ''' .... return # 函数名的命名规范也遵徐变量名的命名规范 # 函数名指向函数的内存地址，是对函数代码的引用，命名需看名知意 函数调用的三种形式： 1. 直接调用 函数名() 2. 作为参数传递 xxx(函数名()) 3. 表达式形式 xxx = 函数名() xxx = 函数名 # 此刻 xxx关联的内存地址就是此函数封装代码的内存地址，调用xxx()就是调用函数 函数的三要素： 1. 参数 2. 函数名 3. 返回值 -
函数的参数
-
参数顺序：位置参数, 默认参数, *args, 命名关键字参数, **kwargs,
-
参数的数据类型：在python中不会限制参数的数据类型，只作为一个提示的功能
def xxx(a:int, b:float, c:string): pass -
位置参数：按照形参位置，顺序传入实参
def xxx(a, b, c): pass xxx(1, 2, 3) -
默认参数：如果不给定参数，则使用默认的值
def xxx(a=10): pass -
可变参数：可接收任何位置参数，使用元组存储
def zzw(a,b,*c): print(a,b,c,type(c)) zzw(1,2,3,4,5,6,7) # 1 2 (3, 4, 5, 6, 7) <class 'tuple'> # 对应的可变参数使用元组存储 -
命名关键字参数：我们有时候需要定义，一些参数必须使用 k=v 的形式来传值
def register(name,age,*,sex,height): #sex,height为命名关键字参数 pass # 被定义为命名关键字的参数，必须 以 k=v 的形式传值，否则报错！ register('lili', 18, sex='male', height='1.8m') # 正确使用 -
可变长关键字参数：可以接收任何关键字参数，使用字典存储
def foo(x,**kwargs): #在最后一个参数kwargs前加** print(x) print(kwargs) foo(y=2,x=1,z=3) # 溢出的关键字实参y=2，z=3都被**接收，以字典的形式保存下来，赋值kwargs # 1 # {'z': 3, 'y': 2} -
参数的组合：定义顺序必须是：位置参数、默认参数、*args、命名关键字参数、**kwargs
-
-
函数的返回值
- 一个return语句，可以使用逗号隔开，返回多个值，使用元组存储
- 一个函数只能有一个return语句，除非使用finally关键字
- return语句就是代表函数的执行结束
-
函数的注释
- 可以使用help()内置函数来查看函数内部的注释
-
全局变量/局部变量
- 全局变量：在整个py文件内均生效
- 局部变量：只能在局部生效，如函数内部定义的变量，只能在函数启动时生效，结束时回收
- globals()：查看对象的全局变量，以字典的形式返回
- locals()：查看当前作用域内的局部变量，以字典的形式返回
-
名称空间
- 内建名称空间：随python解释器的启动而生成，结束而回收，用于存储python解释器内置的名称
- 全局名称空间：随py文件的执行而产生，结束而回收，用于存储py文件内的全局变量名
- 局部名称空间：随函数的启动而产生，结束而回收，用于存储函数内部的局部变量
-
作用域
- 全局作用域：全局名称空间+内建名称空间的所有名字，在整个py文件的任何位置均生效
- 局部作用域：局部变量仅能在函数执行时的内部生效
-
global、nonlocal关键字
-
global：声明变量为全局变量
a = 100 def zzw(): global a # 使用global对变量进行声明，可以通过函数修改全局变量的值 a = 10 # 此时，全局变量的值变为10 print('函数内部：',a) zzw() print('函数外部：',a) # 函数内部： 10 # 函数外部： 10 -
nonlocal：声明当前变量向外跨越一层
def f1(): x=2 def f2(): nonlocal x x=3 f2() # 调用f2(),修改f1作用域中名字x的值 print(x) # 在f1作用域查看x f1() # 结果 3 # nonlocal x会从当前函数的外层函数开始一层层去查找名字x，若是一直到最外层函数都找不到，则会抛出异常
-
十一、高阶函数
-
递归函数
# 核心原理：函数内部不停调用自己 # 需要找到结束内调的出口 def ceshi(): i = 0 i += 1 print(i) if i == 10: return ceshi() ceshi() -
匿名函数
# python中使用lambda关键字来定义匿名函数 a = lambda x, y: x + y print(a(1, 2)) # 3 -
函数嵌套
# 函数的内部还可以继续嵌套函数 def ceshi1(): def ceshi2(): def ceshi3(): xxx -
闭包函数
# 在一个函数内部再定义一个函数，然后使用return返回该函数的内存地址，实现封装一个函数的作用 def ceshi1(): def ceshi2(): pass return ceshi2 a = ceshi1() # 此刻 a = ceshi2的内存地址 # 返回当前函数内部调用的所有局部函数的内存地址，以元组的形式返回 a.__closure__ # 调用该局部变量的内存地址，获取结果 a.__closure__[0].cell_contents -
装饰器
# 核心原理，将被装饰的函数当作参数传入到装饰器中，返回一个装饰后的方法 # 可以实现在不改变原有代码的情况下，对代码进行性能测试、插入日志等 def ceshi1(func): def ceshi2(): func() print('ceshi2') return ceshi2 @ceshi1 def func1(): print('func1') func1() ''' 返回结果： func1 ceshi2 原先：func1 = func1函数内存地址 装饰： func1 = ceshi1(func1函数内存地址) --> ceshi2函数的内存地址 --> ceshi2内部的func()相当于是func1函数的执行结果 最终：func1 = ceshi2函数内存地址，内部存在func1函数的执行结果 ''' -
多层装饰
# 装饰器并不是可以添加一个，也可以添加多个 def ceshi1(func): def ceshi2(): func() print('ceshi2') return ceshi2 def ceshi3(func): def ceshi2(): func() print('ceshi2') return ceshi2 def ceshi4(func): def ceshi2(): func() print('ceshi2') return ceshi2 ... ... @ceshi4 @ceshi3 @ceshi1 def func1(): print('func1') func1() ''' 相当于： func1 = ceshi4(ceshi3(ceshi1(func1的内存地址))) ''' -
有参装饰器
def xxx(a, b) def ceshi1(func): def ceshi2(*args, **kwargs): func((*args, **kwargs) print('ceshi2', a, b) return ceshi2 return ceshi1() @xxx(1, 2) def func1(*args, **kwargs) print(args) func1(3, 4, 5 ,6) ''' (3, 4, 5 ,6) ceshi2 1 2 ''' -
property关键字
property关键字可以实现对象内部将方法装饰为属性，且额外增加增删改查 class xxx: def __init__(self): self.name = 'list' @property def get_name(self): pass @get_name.getter def get_name(self): return self.name @get_name.setter def get_name(self, value): self.name = value return self.name @get_name.deleter def get_name(self, value): return None a = xxx() a.get_name # 触发 @get_name.getter a.get_name = 13 # 触发 @get_name.setter，传入value del a.get_name # 触发 @get_name.deleter
十二、常用的内置函数
python3存在68个内置函数
-
number
-
数字类型
- int()
- float()
- complex()
-
进制转换
- bin()
- oct()
- hex()
-
数学计算
- abs()
- pow(a, b)
- round(a, b)
- divmod(a, b)
- sum(iterable)
- max(iter)
- min(iter)
-
-
string
-
str(obj)
-
切片对象: slice(start: end: stop)
-
执行python指令
- eval()
- exec()
- compile(str, '', 'eval/exec')
-
输出字符串：repr()
-
格式化字符串：format()
-
-
编码
- chr()
- ord()
- ascii()
-
byte
-
byets(str, encoding='')
-
bytearry(str, encoding='')
-
memoryview(byte)
- tobytes
- tolist
-
-
bool
- bool(obj)
- any(iter)
- all(iter)
-
list
- list(iter)
- 列表排序: sorted(iterable, key, reverse)
- 压缩列表：zip(iter, iter...)
-
set
- set(iter)
- 冰冻集合: frozenset(iterable)
-
dictionary
- dict(iter)
-
tuple
- tuple(iter)
-
可迭代对象
-
next()
-
迭代器
- iter()
- 翻转迭代器：reversed()
- 生成序列迭代器：range()
- 迭代加工：map(func, iter)
- 迭代过滤：filter(func, iter)
-
-
对象
-
dir()
-
vars()
-
object()
-
property()
-
继承相关
- isinstance(obj, (class, ...))
- isinsubclass(class, (class, ...))
- super()
-
特殊对象：enumerate()
-
文件对象：open()
-
模块导入：
__import__() -
反射：
- getattr(obj, 'name', default)
- setattr(obj, 'name', 'new')
- delattr(obj, 'name')
- hasattr(obj, 'name')
-
对象修饰符
- @classmethod
- @staticmethod
-
-
函数
- 是否可调用：callable()
- 局部变量：locals()
- 全局变量：globals()
-
输入输出
- print()
- input()
-
其他：
- id()
- type()
- help()
- hash()
- exit()
浙公网安备 33010602011771号