分类: Python/Ruby
2020-07-13 16:15:15
大家好,为大家带来python中核心知识的讲解,不讲最基础的语法,这个大家都能轻松学会,不耽误时间,只有干货。
>>>help('__main__') 退出键 注:help函数用来查看帮助或运行时信息
每个对象会记录有几个变量引用自身,当引用的数量为0时此对象被销毁,此种自动化内存管理的方式叫引用计数。
is的作用:判断两个对象是否是同一个对象(比较内存中的地址),当是同一个对象返回True,否则返回False, is not 的作用与 is相反
CPython 中 整数 -5 至 256永远存在于小整数对象池中,不会释放并可重复使用
作用:返回一个对象在内存中的地址
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(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)
# 将1-20的偶数用filter生成可迭代对象后,将可迭代对象生成的数据存于列表中 l = list(filter(lambda x : x%2==0, range(1,21))) print(l)
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)
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 函数名(参数列表): '''函数文档字符串''' 语句块
def mysum(n): '''1 + 2 + 3 + 4 + ...+ n''' return 100 help(mysum)
__doc__属性用于记录文档字符串
__name__属性用于记录函数名
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语句和迭代器实现
生成器是能够动态提供数据的对象,生成器对象也是可迭代对象(实例)
生成器的两种方式
含有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)
浅拷贝是指在复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程
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]]
复制对象及对象关联的对象一起复制过程叫深拷贝
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 ='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'
bool, int, float, complex, str, tuple, frozenset, bytes
list, dict, set, bytearray
返回所有属性的字符串列表
语法 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('程序正常退出')