学会这些会让你对python有个更深的理解

大家好，为大家带来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'
  将其转化为列表,列表的内部是整数
  L = [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('程序正常退出')