共计 9307 个字符，预计需要花费 24 分钟才能阅读完成。
大家好，为大家带来 python 中外围常识的解说，不讲最根底的语法，这个大家都能轻松学会，不耽误时间，只有干货。
查看以后作用域内的所有变量
>>>help('__main__')
退出键
注：help 函数用来查看帮忙或运行时信息自动化内存治理和援用计数
每个对象会记录有几个变量援用本身，当援用的数量为 0 时此对象被销毁，此种自动化内存治理的形式叫援用计数。
is/is not 运算符
is 的作用：判断两个对象是否是同一个对象（比拟内存中的地址)，当是同一个对象返回 True，否则返回 False，is not 的作用与 is 相同
小整数对象池
CPython 中 整数 -5 至 256 永远存在于小整数对象池中，不会开释并可重复使用
id(x) 函数
作用：返回一个对象在内存中的地址
bool(x)返回假值的状况
bool(x)用于显示获取 x 的布尔值
假值状况
None 空值
False 布尔假值
0 0.0 0j 所有数字零
'' 空字符串
[] 空列表
() 空元组
{} 空字典
set() 空集合
.... 所有空的容器对象 bool(x)取值为假推导式
列表推导式
列表推导式是用可迭代对象创立列表的表达式
- 作用：用繁难办法生成列表
-
语法:
[表达式 for 变量 in 可迭代对象] 或 [表达式 for 变量 in 可迭代对象 if 真值表达式] -
示例：
# 生成一个数值为 1~9 的平方的列表 # [1, 4, 9, 16, .... 81] # 不必推导式: L = [] for i in range(1, 10): L.append(i**2) # 推导式实现 L = [i ** 2 for i in range(1, 10)]# 用列表推导式生成 1~100 以内奇数的列表, 后果是:[1, 3, 5, 7, ...., 99] # 答案: [i for i in range(1, 100, 2)] # 或 [i for i in range(1, 100) if i % 2 == 1]
列表推导式的嵌套
-
语法:
[表达式 for 变量 1 in 可迭代对象 1 if 真值表达式 1 for 变量 2 in 可迭代对象 2 if 真值表达式 2 ...] -
示例：
# 将列表 [10, 20, 30] 中的元素与列表[1,2,3] 元素别离相加, 将失去的元素放于一个列表中 L = [x + y for x in [10, 20, 30] for y in [1,2,3]] print(L) #[11, 12, 13, 21, 22, 23, 31,32,33] -
练习：
1. 用字符串 "ABC" 和字符串 "123" 生成如下列表 ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3',] 2. 已知有一个字符串: s = '100,200,300,500,800' 将其转化为列表, 列表的外部是整数
* 答案：1. [x + y for x in "ABC" for y in "123"]
2. L = [int(x) for x in s.split(',')]
```
字典推导式
是用可迭代对象生成字典的表达式
-
语法：
{键表达式 : 值表达式 for 变量 in 可迭代对象[if 真值表达式]} 注: []示意其中的内容可省略 -
示例:
# 生成一个字典, 键为数字 1 ~ 9, 值为键的平方 d = {x : x ** 2 for x in range(1, 10)}
高阶函数
map 函数
map(func, *iterable)
- 作用：返回一个可迭代对象，此可迭代对象用函数 func 对可迭代对象 iterable 中的每一个元素作为参数计算后得新的数据
-
示例：
# 此示例示意 map 函数的应用 def power2(x): return x**2 for x in map(power2, range(1, 10)): print(x) # 1, 4, 9, 16 ... 81 -
练习：
求 1**2 + 2**2 +3**2 +...+ 9**2 的和 求 1**3 + 2**3 +3**3 +...+ 9**3 的和 -
答案：
s = sum((map(lambda x : x**2, range(1, 10)))) print(s) s = sum((map(lambda x : x**3, range(1, 10)))) print(s)
filter 函数
- 语法: filter(function, iterbale)
-
作用:
- 筛选可迭代对象 iterable 中的数据，返回一个可迭代对象，此可迭代对象只返回 iterable 中符合条件的数据
- function 将对 iterbale 中提供的每个数据进行求布尔值，如果为 True 则保留，否则为 False 抛弃数据
-
示例：
# 将 1 -20 的偶数用 filter 生成可迭代对象后，将可迭代对象生成的数据存于列表中 l = list(filter(lambda x : x%2==0, range(1,21))) print(l) - 练习：
用 filter 函数将 1 -100 之间的所有素数存在列表中 -
答案：
def isprime(n): if n < 2: return False for i in range(2, n): if n % i == 0: return False return True l = list(filter(isprime, range(1,100))) print(l)
sorted 函数
- 作用:
将原可迭代对象的数据进行排序，生成排序后的列表 - 函数参数格局
sorted(iterable, key=None, reverse=False) - 阐明
iterable 可迭代对象
【key 函数】是用来提供一个值，这个值将作为排序的根据，如果不给出 key 函数，则用
原数据的值进行比拟和排序
reverse 标记用来设置是否降序排序 -
示例
l = [5, -2, -4, 0, 3, 1] l2 = sorted(l) # [-4, -2, 0, 1, 3, 5] l3 = sorted(l, reverse=True) # [5, 3, 1, 0, -2, -4] l4 = sorted(l, key=abs) # [0, 1, -2, 3, -4, 5] names = ['Tom', 'Jerry', 'Spike', 'Tyke'] l5 = sorted(names) # ['Jerry', 'Spike', 'Tom', 'Tyke'] names = ['Tom', 'Jerry', 'Spike', 'Tyke'] l5 = sorted(names, key=len) # ['Tom', 'Tyke', 'Jerry', 'Spike'] -
练习
names = ['Tom', 'Jerry', 'Spike', 'Tyke'] 排序的根据为字符串的反序 'moT' 'yrreJ' 'ekipS' 'ekyT' 后果为 ['Spike', 'Tyke', 'Tom', 'Jerry'] -
答案
names = ['Tom', 'Jerry', 'Spike', 'Tyke'] l5 = sorted(names, key=lambda s : s[::-1])
装璜器
装璜器是一个函数，次要作用是用来包装另一个函数或类
包装的目标是在不扭转原函数（或类名）的状况下扭转被包装对象的行为
函数装璜器
是指装璜器是一个函数，传入的是一个函数，返回的是一个函数
-
语法
def 装璜器函数名(参数): 语句块 return 函数对象 @装璜器函数名 < 换行 > def 函数名(形参列表): 语句块 - 原理
被装璜器函数的变量（函数名）绑定装璜器函数调用后的返回的函数 -
示例 1
# 此示例示意装璜器函数的定义和调用装璜器原理 def mydeco(fn): # <<<----- 装璜器函数 def fx(): print('fx 被调用') return fx @mydeco def myfun(): print('myfun 被调用') # 上述 mydeco 的原理是在 def myfun 语句调用之后加了一条如下语句 # myfun = mydeco(myfun) myfun() #调用 myfun myfun() myfun() -
示例 2
# 此示例示意装璜器函数用来包装被装束函数 def mydeco(fn): # <<<----- 装璜器函数 def fx(): print('------ 这个被装璜函数调用之前 -------') fn() # 被调用被装璜函数 print('++++++ 这个被装璜函数调用之后 +++++++') return fx @mydeco def myfun(): print('myfun 被调用') # 上述 mydeco 的原理是在 def myfun 语句调用之后加了一条如下语句 # myfun = mydeco(myfun) myfun() #调用 myfun myfun() myfun() -
示例 3
# 此示例示意装璜器的利用场合及性能 # --------------------- 以下是杨小哥写的程序 -------------------------- def privileged_check(fn): def fx(name, x): print('正在进行权限验证。。。') if True: fn(name, x) else: print('权限验证失败') return fx def message_send(fn): def fy(n, money): fn(n, money) # 调用被装璜函数 print('正在发送短信给', n, '...') return fy # --------------------- 以下是杨小哥写的程序 -------------------------- @ message_send @ privileged_check def savemoney(name, x): print(name, '存钱', x, '元') # 本质是 # savemoney = privileged_check(savemoney) # savemoney = message_send(savemoney) def withdraw(name, x): print(name, '取钱', x, '元') # --------------------- 以下是调用者写的程序 -------------------------- savemoney('小王', 200) savemoney('小赵', 400) withdraw('小李', 500)
函数的文档字符串
函数内第一次未赋值给任何变量的字符串是此函数的文档字符串
-
语法
def 函数名(参数列表): '''函数文档字符串''' 语句块 - 阐明
1. 文档字符串通常用来阐明函数性能和应用办法
2. 在交互模式下，输出:
>>>help(函数名) 能够查看函数的文档字符串
3. 函数的文档字符串绑定在函数的__doc__属性上 -
示例
def mysum(n): '''1 + 2 + 3 + 4 + ...+ n''' return 100 help(mysum)
函数的__doc__属性
__doc__属性用于记录文档字符串
函数的__name__属性
__name__属性用于记录函数名
迭代器和生成器
迭代器 Iterator
- 迭代器是拜访可迭代对象的工具
- 迭代器是指用 iter(obj)函数返回的对象（实例）
- 迭代器能够用 next(it)函数获取可迭代对象的数据
迭代器函数 iter 和 next
iter(iterable)
从可迭代对象中返回一个迭代器，iterable 必须是能提供一个迭代器的对象
next(iterator)
从迭代器 iterable 中获取下一个记录，如果无奈获取下一条记录，则触发 StopIteration 异样
阐明
1. 迭代器只能往前取值，不会后退
2. 用 iter 函数能够返回一个可迭代对象的迭代器示例
l = [1, 3, 5, 7]
it = iter(l) # 让 l 提供一个能拜访本人的迭代器
print(next(it)) # 1 从迭代器中取值，让迭代器去获取 l 中的一个元素
print(next(it)) # 3 从迭代器中取值，让迭代器去获取 l 中的一个元素
print(next(it)) # 5 从迭代器中取值，让迭代器去获取 l 中的一个元素
print(next(it)) # 7 从迭代器中取值，让迭代器去获取 l 中的一个元素
# next(it) # StopIteration 异样迭代器的用处
用迭代器能够顺次拜访可迭代对象的数据
l = [2, 3, 5, 7]
for i in l:
print(l)
# 以下用迭代器来拜访
l = [2, 3, 5, 7]
it = iter(l)
while True:
try:
x = next(it)
print(x)
except StopIteration:
break练习
有一个汇合，s = {'唐僧', '悟空', '八戒', '沙僧'}
用 for 语句来遍历所有元素如下
for x in s:
print(x)
else:
print('遍历完结')
将 for 语句改写为 while 语句和迭代器实现生成器 Generator
生成器是可能动静提供数据的对象，生成器对象也是可迭代对象（实例）
生成器的两种形式
- 生成器函数
- 生成器表达式
生成器函数的定义
含有 yield 语句的函数是生成器函数，此函数被调用将返回一个生成器对象
yield 翻译为（产生或生成）
yield 语句
语法
yield 表达式
阐明
yield 用于 def 函数中，目标是将此函数作为生成器函数应用
yield 用来生成数据，供迭代器和 next(it) 函数应用 示例
# 生成器函数只有在 next(it) 函数调用时才会执行，且遇到 yield 后返回相应的值给 next(it)函数
def my_yield():
print('行将生成 2')
yield 2
print('行将生成 3')
yield 3
print('行将生成 5')
yield 5
print('行将生成 7')
yield 7
print('生成器生成完结')
for i in my_yield():
print(i)
g = my_yield() # 调用生成器函数来创立一个生成器，此生成器能生成 2 3 5 7 四个数
it = iter(g) # 用生成器拿到对应的迭代器
print(next(it))
print(next(it))# 用生成器函数来生成一些列的整数，0 - n
def myinteger(n):
i = 0
while i < n:
yield i
i += 1
for x in myinteger(3):
print(x)
l = [x for x in myinteger(100) if x % 2 == 1]
print(l)生成器函数的阐明
生成器函数的调用将返回一个生成器对象，生成器对象是一个可迭代对象，通常用来动静生成数据
生成器函数调用 return 语句会触发一个 StopIteration 异样
练习
写一个生成器函数，myeven(start, stop)用来生成 start 开始带 stop 完结（不蕴含）的偶数
生成器表达式
语法（表达式 for 变量 in 可迭代对象 [if 真值表达式]）作用
用推导式模式创立一个新的生成器
阐明
if 子句能够省略
示例
gen = (x**2 for x in range(1, 5))
it = iter(gen)
print(next(it)) # 1
print(next(it)) # 4
print(next(it)) # 9
print(next(it)) # 16
print(next(it)) # StopIteration练习
已知有列表
l = [2, 3, 5, 7]
1) 写一个生成器函数，让此函数可能动静提供数据，数据为原列表数字的平方加 1
2) 写一个生成器表达式，让此表达式可能动静提供数据，数据为原列表数字的平方加 1
3) 生成一个列表，此列表内的数据是原列表数据的平方加 1 生成器表达式和列表推导式的区别
l = [2, 3, 5, 7]
l2 = [x ** 2 + 1 for x in l]
it = iter(l2)
print(next(it)) # ?
l[1] = 30
print(next(it)) # ??
# 以下是生成器表达式
l = [2, 3, 5, 7]
l2 = (x ** 2 + 1 for x in l)
it = iter(l2)
print(next(it)) # ?
l[1] = 30
print(next(it)) # ??
# 生成器表达式是现用现生成，列表推导式一次性生成静态数据迭代工具函数
作用是生成一个个性化的可迭代对象
zip(iter1 [, iter2[...]])
返回一个 zip 对象，此对象用于生成元组，此元组的每个数据来源于参数中的可迭代对象，当最小的可迭代对象不再提供数据时迭代完结
enumerate(iterable [, start])ZIP 示例
numbers = [10086, 10000, 10010, 95588]
names = ['中国移动', '中国联通', '中国电信']
for t in zip(numbers, names):
print(t)
for No, number, name in zip(range(1, 100), numbers, names):
print('序号', No, name, '的客服电话是', number)ENUMERATE 示例
names = ['中国移动', '中国联通', '中国电信']
for t in enumerate(names):
print(t)
for t in enumerate(names, 101):
print(t)
# 既能失去索引又能失去值
for index, name in enumerate(name):
print(index, name)练习
写一个程序，读入任意行文字，当输出空行时完结，打印带有行号的输出的后果
如：请输出：abdce < 回车 >
请输出：hello < 回车 >
请输出：bye < 回车 >
请输出：< 回车 >
输入如下：第 1 行：abdce < 回车 >
第 2 行：hello < 回车 >
第 3 行：bye < 回车 >迭代器（高级）
由 iter(iterable) 函数返回，能够通过 next(iterator) 函数取值的对象就是迭代器
迭代器协定
迭代器协定是指对象可能应用 next()函数获取下一项数据，在没有下一项数据时触发一个 StopIteration 异样来终止迭代的约定
迭代器协定的实现办法
def __next__(self):
...
注：此办法须要实现迭代器协定# 此示例示意将自定义的类 MyList 创立的对象制作为可迭代对象
class MyList:
'''这是一个自定义的列表类型，此类型的对象用 data 属性绑定的列表来存储数据'''
def __init__(self, iterable=()):
self.__data = [x for x in iterable]
def __repr__(self):
return 'MyList(%s)' % self.__data
def __iter__(self):
'''此办法用来返回一个能拜访 self 对象'''
'''此办法用来返回一个能拜访 self 对象迭代器'''
# return iter(self.__data)
return MyListIterator(self.__data)
class MyListIterator:
'''此类用来形容可能拜访 MyList 类型的对象的迭代器'''
def __init__(self, lst):
self.__data_lst = lst
self.__cur_index = 0 #迭代器的起始地位
def __next__(self):
'''此办法用来实现迭代器协定'''
if self.__cur_index >= len(self.__data_lst):
raise StopIteration
r = self.__data_lst[self.__cur_index]
self.__cur_index += 1
return r
myl = MyList([2, 3, 5, 7])
# ################
it = iter(myl) # 等同于 it = myl.__iter__()
print(next(it)) # 2
# ################
for x in myl:
print(x)深拷贝和浅拷贝
浅拷贝 shallow copy
浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy() # 浅拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]深拷贝 deep copy
复制对象及对象关联的对象一起复制过程叫深拷贝
import copy # 导入复制模块
L= [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) # 深拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1) # [1, 2, [3.1, 3.2]] <<< L1 不变
print(L2) # [1, 2, [3.14, 3.2]]字符串的文本解析办法
- S.split(sep=None) 将字符串，应用 sep 作用分隔符宰割 S 字符串，返回宰割后的字符串列表，当不给定参数时，用空白字符作为分隔符宰割
- S.join(iterable) 用可迭代对象中的字符串，返回一个两头用 S 进行分隔的字符串
s ='Beijing is capital'
L = s.split('') # L = ['hello','world','tarena']
s2 = "hello#world#tarena"
L = s2.split('#') # L = ['hello', 'world', 'tarena']
L = ['aaa', 'bbbb', 'ccccc']
'$'.join(L) # 生成 'aaa$bbbb$ccccc'python3 中不可变数据类型
bool, int, float, complex, str, tuple, frozenset, bytes
python3 中可变数据类型
list, dict, set, bytearray
dir(obj) 函数
返回所有属性的字符串列表
with 语句深层次解说
语法
with 表达式 1 [as 变量 1], 表达式 2 [as, 变量 2], ....
语句块
作用
应用于对资源进行拜访的场合，确保应用过程中不论是否产生异样都会执行必须 "清理" 的操作，并开释资源
如
文件关上后主动敞开，线程中锁的主动获取和开释等
阐明
as 字句中的变量用于绑定表达式执行后生成的对象
with 语句并不会扭转异样的状态环境管理器
1. 类内有__enter__ 和 __exit__ 实例办法的类创立的对象被称为环境管理器
2. 可能应用 with 语句进行治理的对象必须是环境管理器
3. __enter__ 办法将在进入 with 语句时被调用，由 as 变量绑定返回的对象
4. __exit__ 办法将在来到 with 语句时被主动调用，且能够通过参数来判断来到 with 语句时是否有异样产生 示例
class A:
'''此类对象能够用于 with 语句进行治理'''
def __enter__(self):
print('此办法是在 with 语句内执行的')
return self # self 将被 with 中的 as 变量绑定
def __exit__(self, exc_type, exc_val, exc_tb):
''' exc_type 用来绑定谬误类型, 当没有异样产生时绑定 None
exc_val 用来绑定谬误对象，当内有产生异样时绑定 None
exc_th 用来绑定 TraceBack 对象，当没有异样时绑定 None
'''
if exc_type is None:
print('您已来到 with 语句, 来到时没有产生任何异样')
else:
print('您已来到 with 语句')
print('谬误类型是：', exc_type)
print('谬误的数据是：', exc_val)
print('Traceback：', exc_tb)
with A() as a:
print('这是 with 语句外部的输入')
int(input('输出：'))
print('程序失常退出')
正文完
