[转载] python3.x总复习

参考链接： Python的string.punctuation

python3.x总复习

1. python有六种基本数据类型：数字number，字符串str，列表list，元组tuple，字典dict和集合set，其中数字，字符串和元组是不可变数据类型。

数字： python中的数字类型包括四种：整型int, 长整型long, 浮点型float, 复数complex。python3.x中把int都改成long，然后对外申称都是int了，所以没有long()函数。简单易错的数字运算：

>>>1/2

0.5

>>>1//2

>>>-3**2

-9

>>>import cmath

>>>cmath.sqrt(-1)

数字间的转换函数及其它函数

int (x[, base])将x转换为int型数字float (x)将x转换为浮点型数字complex (real [, imag])创建一个复数hex( x )将整数x转换为其十六进制形式的字符串oct( x )将整数x转换为其八进制形式的字符串round(expr)计算表达式，并将结果四舍五入floor(x)对数字x向下取整，使用时需要import mathceil(x)对数字x向上取整，使用时需要import math

>>>int('12')

>>>int(12.6)

>>> float('5')

5.0

>>> float(5)

5.0

>>> complex('5')

(5+0j)

>>> complex(5)

(5+0j)

>>> complex(5, 6)

(5+6j)

>>> complex(5, '6')

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: complex() second arg can't be a string

>>> complex('5', 6)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: complex() can't take second arg if first is a string

>>> hex(10)

'0xa'

>>> oct(10)

'0o12'

>>> round(3/2)

>>> import math

>>> math.floor(1.9)

>>> math.ceil(1.1)

为减少内存，python使用内存池来管理小的整型数和小的字符串等等。对于以下赋值：a = 123, b = 123理论上是要分别在内存中创建两个值，然后赋值给变量的，但是这样做实在是有点浪费，明明是一样的数，却要占用两个内存空间。所以在python中，当小的整型（-5~257，不包括257）要多次创建时，只创建一次，后面的都将引用指向同一个地方。例如：

>>> a = 256

>>> b = 256

>>> id(a)

1578732544

>>> id(b)

1578732544

>>> a is b

True

>>> c = 257

>>> d = 257

>>> id(a)

2843231823536

>>> id(b)

2843231825200

>>> a is b

False

字符串：字符串的连接方式：

>>> "hello"' '"world"

'hello world'

>>> "hello" + "world"

'helloworld'

>>> 3*"hello"

'hellohellohello'

字符串的常用函数：

str(x)把值转换为合理的字符串形式，以便用户理解repr(x)会创建一个字符串，它以合法的python表示形式来表示值，以供解释器读取；它和str()的区别是，当值为字符串时，str()返回的是字符串本身’123’，而repr()返回的是解释器读取的字符串，" ‘123’ "len(x)返回字符串的长度str.upper()将字符串中的字母全部变为大写str.lower()将字符串中的字母全部变为小写str.swapcase()将字符串中的字母大小写互换str.capitalize()字符串的首字母大写，其它字母不变str.title()所有单词的首字母大写str.isdigit()判断字符串str是否只由数字组成str.isalpha()判断字符串str是否只有字母组成str.strip()去掉字符串两端的空格（如果有的话）str.split(x)将字符串用x分割，返回一个列表；如果没有参数则默认以空格分割。str.join(lst)用字符串str将列表lst中的元素连接起来；列表lst中的元素应为str类型str.replace(old, new[, max])把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。返回替换后的字符串，不改变原字符串。str.maketrans(intab, outtab)用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同，为一一对应的关系。该函数通常与str.translate()一起使用;最后返回一个转换表，它是一个字典，键为intab中的字符对应的ascii码，值为outtab中相应的字符对应的ascii码str.translate(trantab)以maketrans()函数的返回值为参数，将str字符串进行转换，返回一个新的字符串，不改原有字符串

>>> str(12)

'12'

>>> repr(12)

'12'

>>> str('12')

'12'

>>> repr('12')

"'12'"

>>> print(str('12'))

>>> print(repr('12'))

'12'

>>> 'ab12'.upper()

'AB12'

>>> 'ABc12'.lower()

'abc12'

>>> 'ABc12'.swapcase()

'abC12'

>>> 'hello world'.capitalize()

'Hello world'

>>> 'hello world'.title()

'Hello World'

>>> '12'.isdigit()

True

>>> 'abc'.isalpha()

True

>>> ' hello world '.strip()

'hello world'

>>> ' hello world '.split('o')

[' hell', ' w', 'rld ']

>>> '++'.join(['1', '2', '3'])

'1++2++3'

>>> a = 'hello'

>>> b = a.replace('l', 'm')

>>> a

'hello'

>>> b

'hemmo'

>>> c = a.replace('l', 'm', 1)

>>> c

'hemlo'

>>> d = 'hello'

>>> d[0]

'h'

>>> d[0] = 'm'

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

>>> e = 'abc'

>>> f = '123'

>>> str.maketrans(e, f)

{97: 49, 98: 50, 99: 51}

>>> intab = 'aeiou'

>>> outtab = '12345'

>>> trantab = str.maketrans(intab, outtab)

>>> h = 'this is string example...wow!'

>>> i = h.translate(trantab)

>>> h

'this is string example...wow!'

>>> i

'th3s 3s str3ng 2x1mpl2...w4w!'

注意，由于字符串是不可变的数据类型，故不能使用下标改变字符串的值： d = ‘hello’ d[0] = 'm’会报错

string模块中常用的字符串常量（使用时需要import string）： string.digits：包含数字0-9的字符串； string.ascii_letters：包含所有字母（大写小写）的字符串； string.ascii_lowercase：包含所有小写字母的字符串； string.printable：包含所有可打印的字符的字符串； string.punctuation：包含所有标点的字符的字符串； string.ascii_uppercase：包含所有大写字母的字符串；

字符串格式化：方法1：基本的转换说明符（顺序至关重要）： 1，%字符：标记转换说明符的开始； 2，转换标志（可选）：’-‘表示左对齐；’+‘表示在转换值之前要加上正负号；’ ‘（空白字符）表示正数之前保留空格；0表示转换值若位数不够则用0填充； 3，最小字段宽度（可选）：转换后的字符串至少应该具有该值制定的宽度；如果是’’，则宽度值会从值元组中读出； 4，点（.）后跟精度值（可选）：如果转换的是实数，精度值就表示出现在小数点后的位数；如果转换的是字符串，该值就表示最大字段宽度；如果是’’，那么精度将会从元组中读出； 5，转换类型；转换类型如下：

转换类型含义d， i带符号的十进制数o不带符号的八进制数u不带符号的十进制数x不带符号的十六进制数e科学记数法表示的浮点数f，F十进制浮点数c单字符（接受整数或者单字符字符串）r字符串（使用repr转换任意python对象）s字符串（使用str转换任意python对象）

import math

>>> '%-5.4f'%math.pi

'3.1416'

>>> '%-10.4f'%math.pi

'3.1416 '

>>> '%10.4f'%math.pi

' 3.1416'

>>> '%010.4f'%math.pi

'00003.1416'

>>> '%06.4f'%math.pi

'3.1416'

>>> '%05.4f'%math.pi

'3.1416'

>>> '%01.4f'%math.pi

'3.1416'

方法2：通过使用{ }代替%： 1、正常使用

>>> print("我叫{}，今年{}岁了".format("小李", 20))

我叫小李，今年20岁了

2、还可以通过在括号里填写数字，修改格式化的顺序

>>> print("我叫{1}，今年{0}岁了".format("小李", 20))

我叫20，今年小李岁了

3、通过key取变量

>>> print("我叫{name}，今年{age}岁了".format(name="小李", age=20))

我叫小李，今年20岁了

4、传入对象

>>> class Person:

... def __init__(self,name,age):

...... self.name,self.age = name,age

... def __str__(self):

...... return '我叫{self.name}, 今年{self.age}岁了'.format(self=self)

>>> str(Person('小李',20))

'我叫小李, 今年20岁了'

5、通过下标

>>> person=['小李',20]

>>> '我叫{0[0]}, 今年{0[1]}岁了'.format(person)

'我叫小李, 今年20岁了'

6、填充与对齐格式限定符，语法是{}中带:号填充常跟对齐一起使用^、<、>分别是居中、左对齐、右对齐，后面带宽度。:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

>>> '{:>8}'.format('189')

' 189'

>>> '{:>8}'.format('189')

>' 189'

>>> '{:0>8}'.format('189')

'00000189'

>>> '{:a>8}'.format('189')

'aaaaa189'

7、精度与类型f

>>> '{:.2f}'.format(321.33345)

'321.33'

其中.2表示长度为2的精度，f表示float类型8、其他类型主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

>>> '{:b}'.format(17)

>'10001'

>>> '{:d}'.format(17)

'17'

>>> '{:o}'.format(17)

'21'

>>> '{:x}'.format(17)

'11'

用，号还能用来做金额的千位分隔符。

>>> '{:,}'.format(1234567890)

'1,234,567,890'

#字典：使用双*

>>> li = {'name': 'hello', 'age': 18}

>>> 'name is, {name}, age is {age}'.format(**li)

'name is, hello, age is 18'

#列表：使用单*

>>> li = ['hello', 18]

>>> 'name is {} age is {}'.format(*li)

'name is hello age is 18'

使用f：

>>> price = 1.23

>>> f'price in euro:{price}'

'price in euro:1.23'

4, 使用Ljust(左对齐), rjust（右对齐）, center（居中）,zfill

>>> s = 'python'

>>> s.center(10)

' python '

>>> s.center(10, '*')

'**python**'

>>> s.ljust(12)

'python '

>>> s.rjust(12)

' python'

>>> s.ljust(12, '*')

'python******'

通用序列操作：所有序列类型都可以进行某些特定的操作，这些操作包括：索引，分片，加，乘，以及检查某个元素是否属于序列的成员。除此之外，python中还有计算序列长度，找出最大元素和最小元素的内建函数。分片： numbers[a : b : step]：当step为正数时，只要在numbers中，索引a的位置出现在索引b的位置右边，则返回一个空列表；当step为负数时，只要在numbers中，索引a的位置出现在索引b的位置的左边，也将返回一个空列表。分片满足左闭右开原则，即不管step是负数还是正数，索引a的位置对应的元素为闭。列表：列表方法：

lst.append(x)将对象x添加到lst末尾lst.extend(x)在列表lst的末尾一次性加另一个序列x的多个值lst.insert(index, x)在列表的指定位置Index插入对象xlst.pop(index)移除列表lst中指定位置Index中的对象x;如果没有参数则默认是最后一个位置；其返回值是移除的值lst.remove(x)移除列表lst中的指定元素x的第一个匹配项lst.reverse()用来将lst中的所有元素反转lst.sort()在原位置对lst进行排序

>>> a = [1, 2, 3]

>>> a.append([4])

>>> a

[1, 2, 3, [4]]

>>> a.extend([5])

>>> a

[1, 2, 3, [4], 5]

>>> a.insert(2, [6])

>>> a

[1, 2, [6], 3, [4], 5]

>>> print(a.pop(1))

>>> a

[1, [6], 3, [4], 5]

>>> a.reverse()

>>> a

[5, [4], 3, [6], 1]

元组构造一个包含一个元素的元组时逗号必不可少，如下：

>>> 1

>>> 1,

(1,)

>>> (1)

>>> (1,)

(1,)

>>> (1.)

1.0

字典可以使用dict()函数来创建字典（dict不是一个真正的函数，它是一个类型，向list，typle一样） dict的简单常用方法：

dict.keys()获取键，其返回值是dict_keys类型，无法用下标进行访问，但可迭代dict.values()获取值, 其返回值是dict_values类型，无法用下标进行访问，但可迭代dict.items()获取元素, 其返回值是dict_items类型，无法用下标进行访问，但可迭代dict.get(key[, s])更宽松的访问字典项的方法，如果试图访问字典中不存在的项时返回‘None’，当然也可以用s替换默认值

>>> item = [('a', 'b'), (1, 2)]

>>> a = dict(item)

>>>a

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

>>> a.keys()

dict_keys(['a', 1])

>>> type(a.keys())

>>> a.values()

dict_values(['b', 2])

>>> type(a.values())

>>> a.items()

dict_items([('a', 'b'), (1, 2)])

>>> type(a.items())

>>> a.get('a')

'b'

>>> a.get('b')

>>> print(a.get('b'))

None

>>> a.get('b', 'haha')

'haha'

2，python中的深复制与浅复制 python的深复制deepcopy()与浅复制copy()函数使用时需要导入copy包。对于深复制，会复制包括对象的子对象在内的所有对象，

>>> import copy

>>> a = [1, 2, [3, 4], 5]

>>> b = copy.copy(a)

>>> b.append(6)

>>> b

[1, 2, [3, 4], 5, 6]

>>> a

[1, 2, [3, 4], 5]

>>> b[2].append(7)

>>> b

[1, 2, [3, 4, 7], 5, 6]

>>> a

[1, 2, [3, 4, 7], 5]

>>> c = copy.deepcopy(a)

>>> c

[1, 2, [3, 4, 7], 5]

>>> c.append(8)

>>> a

[1, 2, [3, 4, 7], 5]

>>> c

[1, 2, [3, 4, 7], 5, 8]

>>> c[2].append(9)

>>> c

[1, 2, [3, 4, 7, 9], 5, 8]

>>> a

[1, 2, [3, 4, 7], 5]

3. lambda表达式 lambda的主体是一个表达式，而不是代码块，仅仅能在lambda表达式中封装有限的逻辑进去，起到函数速写的作用。 lambda表达式的简单例子如下：

>>>lambda x, y: x + y

其中x, y为传入函数的参数，x + y为函数体内执行的语句，且计算结果作为返回值返回，其等价的语句如下：

>>>def add(x, y):

>>>...return x + y

lambda表达式通常用在如下情况下： 1）应用在函数式编程中，比如使用在map, reduce, filter, sorted等函数内； 2）应用在闭包中；

4.zip（lst1, lst2）函数 zip(lst1, lst2)函数用来实现并行迭代，返回一个zip的可迭代对象，举例如下：

>>> names = ['a', 'b', 'c', 'd']

>>> ages = [1, 2, 3, 4]

>>> zip(names, ages)

>>> names = ['a', 'b', 'c', 'd']

>>> ages = [1, 2, 3, 4]

>>> zips = zip(names, ages) # [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> type(zips)

>>> for i, j in zips:

... print(i, j)

...

a 1

b 2

c 3

d 4

5. enumerate（sequence，[start = 0]）函数：编号迭代

>>> a = [1, 2, 3, 4]

>>> b = enumerate(a, start = 2)

>>> b

>>> list(b)

[(2, 1), (3, 2), (4, 3), (5, 4)]

6. python中的时间戳三种时间：时间戳，结构化时间，格式化时间

>>>import time

>>>myTime = time.time() #获取时间戳myTime

>>>print(f'当前时间戳：{myTime}')

1548231402.518365

>>> localtime = time.localtime(myTime) #将时间戳转换为本地时间（北京时间）得到struct_time

>>> print(localtime)

time.struct_time(tm_year=2019, tm_mon=1, tm_mday=23, tm_hour=16, tm_min=16, tm_sec=42, tm_wday=2, tm_yday=23, tm_isdst=0)

>>> gmtime = time.gmtime(myTime) #将时间戳转换为格林兰治时间,得到struct_time

>>> print(gmtime)

time.struct_time(tm_year=2019, tm_mon=1, tm_mday=23, tm_hour=8, tm_min=16, tm_sec=42, tm_wday=2, tm_yday=23, tm_isdst=0)

>>> myTime = time.mktime(localtime) #将struct_time转换为时间戳

>>> print(myTime)

1548231402.0

>>> strftime = time.strftime('%y-%m-%d %H:%M:%S', localtime) #使用strftime()将struct_time转换为格式化时间

>>> print(strftime)

19-01-23 16:16:42

>>> asctime = time.asctime(localtime) #使用asctime()将struct_time转换为格式化时间

>>> print(asctime)

Wed Jan 23 16:16:42 2019

7. 装饰器的使用装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的应用有插入日志、增加计时逻辑来检测性能、加入事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。实例如下：

import time

def foo():

print('in foo()')

def timeit(func):

#定义一个内嵌的包装函数，给传入的函数加上计时功能的包装

def wrapper():

start = time.clock()

func()

end = time.clock()

print('used:', end - start)

return wrapper

foo = timeit(foo)

foo()

也可以使用@语法糖如下：

import time

def timeit(func):

def wrapper():

start = time.clock()

func()

end = time.clock()

print('used:', end = start)

return wrapper

@timeit

def foo():

print('in foo()')

foo()

如果想为装饰器传入函数，可以在最外层再嵌套一个函数，示例如下：

import time

from functools import reduce

def timeit(name = 'None'):

def inner(func):

def wrapper(*args, **argv):

print(f'这个装饰器的名字是：{name}')

old = time.time()

func(*args, **argv)

new = time.time()

spend = new - old

print(f'you have spend : {spend}')

return wrapper

return inner

@timeit(name = 'wukeke')

def add(*args, **argv):

args = list(args)

print(reduce(lambda x, y: x + y, args))

add(1, 2, 3, 4, 5, age = 20)

8.map(), reduce(), filter()函数的使用方法 1）map：python中的一个类，其构造函数：map(func, *iterables)：它接收一个函数 func 和一个 *literables，并通过把函数 func 依次作用在 *literables 的每个元素上，得到一个新的迭代器并返回。它不改变原有的literables; 例子：

当seq只有一个时，将函数func作用于这个seq的每个元素上，并得到一个新的seq。

>>>lst = [1, 2, 3]

>>>print(list((map(lambda x: x * x, lst))))

[1, 4, 9]

当seq多于一个时，map可以并行（注意是并行）地对每个seq执行:

>>>print(list(map(lambda x, y: x**y, [1, 2, 3], [1, 2, 3])))

[1**1, 2**2, 3**3]

python3中可以处理类表长度不一致的情况，但无法处理类型不一致的情况

>>>print(list(map(lambda x, y: (x**y, x+y), [1, 2, 3], [1, 2])))

[(1, 2), (4, 4)]

特殊用法：做类型转换：例子1：

>>>a = list(map(int, ['1234']))

>>>print(a)

[1234]

>>>print(type(a[0]))

例子2:

>>>a = list(map(int, '1234'))

>>>print(a)

[1, 2, 3, 4]

>>>print(type(a[0]))

2）reduce()：使用reduce()函数需要导入functools库；

reduce(...):

reduce(function, sequence[, initial]) -> value

Apply a function of two arguments cumulatively to the items of a sequence,

from left to right, so as to reduce the sequence to a single value.

For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates

((((1+2)+3)+4)+5). If initial is present, it is placed before the items

of the sequence in the calculation, and serves as a default when the

sequence is empty.

function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素, 和上一次调用function的结果做参数再次调用function。第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。

>>>reduce(lambda x, y: x + y, [2, 3, 4, 5, 6], 1)

#等价于((((((1+2)+3)+4)+5)+6))

>>>reduce(lambda x, y: x + y, [2, 3, 4, 5, 6])

3)filter()函数： Python内建的filter()函数用于过滤序列。和map()类似，filter()也接收一个函数和一个序列。和map()不同的时， filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False 决定保留还是丢弃该元素。返回一个迭代器例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

def is_odd(n):

return n % 2 == 1

a = filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])

print(list(a))

# 结果: [1, 5, 9, 15]

9. property的使用方法在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改：

s = Student()

s.score = 9999

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

def get_score(self):

return self._score

def set_score(self, value):

if not isinstance(value, int):

raise ValueError('score must be an integer!')

if value < 0 or value > 100:

raise ValueError('score must between 0 ~ 100!')

self._score = value

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了：

>>> s = Student()

>>> s.set_score(60) # ok!

>>> s.get_score()

>>> s.set_score(9999)

Traceback (most recent call last):

...

ValueError: score must between 0 ~ 100!

但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来说，这是必须要做到的！还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

@property

def score(self):

return self._score

#注意，在这里，使用了@property生成器后会自动生成@函数名.setter生成器用来将生成的score

#属性变成可以修改；而如果不使用@函数名.setter生成器，则生成的属性只读；

@score.setter

def score(self, value):

if not isinstance(value, int):

raise ValueError('score must be an integer!')

if value < 0 or value > 100:

raise ValueError('score must between 0 ~ 100!')

self._score = value

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

>>> s = Student()

>>> s.score = 60 # OK，实际转化为s.set_score(60)

>>> s.score # OK，实际转化为s.get_score()

>>> s.score = 9999

Traceback (most recent call last):

...

ValueError: score must between 0 ~ 100!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

@property

def birth(self):

return self._birth

@birth.setter

def birth(self, value):

self._birth = value

@property

def age(self):

return 2014 - self._birth

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。小结 @property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

from decimal import Decimal

class Fees(object):

def __init__(self):

self._fee = None

def get_fee(self):

return self._fee

def set_fee(self, value):

if isinstance(value, str):

self._fee = Decimal(value)

elif isinstance(value, Decimal):

self._fee = value

fee = property(get_fee, set_fee)

f = Fees()

f.set_fee('1')

print(f.fee)

#输出1

f.fee = '2'

print(f.fee)

#输出2

10. type()和isinstance()的区别 isinstance(object, classinfo):判断object是否是classinfo类或其子类的实例； type():只能判断是否是该类本身的实例；

11，迭代器与生成器迭代器的特殊方法__iter__():这个方法是迭代器规则的基础； __iter__方法返回一个迭代器，所谓的迭代器就是具有next（）方法的对象。在调用next()方法时，迭代器会返回他的下一个值。如果next（）方法被调用，但是迭代器没有值可以返回，则会返回一个StopIteration异常；例如，斐波那契数列的迭代器实现如下：

class Fibs:

def __init__(self):

self.a = 1

self.b = 1

def __next__(self):

self.a, self.b = self.b, self.a + self.b

return self.a

def __iter__(self):

return self

f = Fibs()

print(f)

for i in range(10):

print(next(f))

#输出结果是：

<__main__.Fibs object at 0x000001D69B285EF0>

一个实现了__iter__()方法的对象是可迭代的，而一个实现了__next__()方法的对象是迭代器

生成器：任何包含yield语句的函数称为生成器。除名字不同外，它和普通函数也有很大的不一样。这在于它不像return那样返回值，而是每次产生多个值。每次产生一个值（使用yield语句），函数就会被冻结；函数被激活后就从被冻结的那点开始执行。示例如下：

def flatten(nested):

try:

for sublist in nested:

for element in flatten(sublist):

yield element

except TypeError:

yield nested

nested = [1, 2, 3, [4, 5], [6, [7, [8, [9]]]]]

print(list(flatten(nested)))

#结果是：

#[1, 2, 3, 4, 5, 6, 7, 8, 9]

生成器是一个包含yield语句的函数。当它被调用时，在函数体中的代码不会被执行，而是返回一个迭代器。每次请求一个值，就会执行生成器中的代码，直到遇到一个yield或者return 语句。yield语句意味着应该生成一个值，return语句意味着生成器要停止运行。换句话说，生成器由两部分组成：生成器的函数和生成器的迭代器。生成器的函数是用def语句定义的，而生成器的迭代器是这个函数的返回部分。

生成器方法：生成器的新属性是在开始运行后为生成器提供值的能力。表现为生成器和”外部世界“进行交流的渠道。通常需要注意一下两点： 1）外部作用域访问生成器的send方法时，就像访问next()方法一样，只不过前者使用一个参数（要发送的”消息“——任意对象） 2）在内部则挂起生成器，yield现在作为表达式而不是语句使用。换句话说，当生成器重新运行时，yield方法返回一个值，也就是send（）方法发送的值。如果next()方法被使用则返回None。注意，使用send（）方法（而不是next（）方法）只有在生成器挂起后才有意义（也就是说在yield第一次执行之后。）如果在此之前需要给生成器提供更多的信息，那么需要使用生成器函数的参数。如果真想对刚刚启动的生成器使用send（）方法，那么可以将None作为参数对其进行调用。简单示例如下：

def repeater(value):

while True:

new = (yield value)

if new is not None:

value = new

#使用方法如下：

r = repeater(42)

print(next(r))

print(r.send('hello world'))

print(next(r))

#输出结果如下：

hello world

12.python中的类定义类的私有方法或属性：在方法名或属性名前面加双下划线：‘__’。python中的私有属性或方法并不是真正意义上的类外无法使用的属性或方法，它只是作者用来告诉使用该类的程序员该方法或属性不允许在类外使用。如果一定要在类外使用私有方法或属性也可以，只要在该私有方法或属性的前面加上’_'与该类名即可。

class student():

__name = 'wukeke'

__age = 21

def __private(self):

print(f'name: {self.__name}, age: {self.__age}')

s = student()

print(s._student__name)

s._student__private()

#输出结果如下：

wukeke

name: wukeke, age: 21

使用多重继承时需要注意：如果一个方法(或属性)从多个超类继承（也就是说你有两个具有相同名字的不同方法），那么必须注意一下超类的顺序（在CLASS语句中），先继承的类中的方法会重写后继承的类中的方法；

13.深入了解sort()与sorted()函数 sorted()函数：用来将可迭代的对象进行排序。python3.x中的sorted()函数取消了对cmp的支持。

sorted(iterable, /, *, key=None, reverse=False)

Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the

reverse flag can be set to request the result in descending order.

1）使用key排序：

#使用首字母排序

>>>list1 = [('david', 90), ('mary', 90), ('sara', 80), ('lily', 95)]

>>>print(sorted(list1, key = lambda x:x[0]))

[('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]

2）用reverse反转排序结果：

>>>list1 = [('david', 90), ('mary', 90), ('sara', 80), ('lily', 95)]

>>>print(sorted(list1, key = lambda x:x[0], reverse = True))

[('sara', 80), ('mary', 90), ('lily', 95), ('david', 90)]

14. python中的运算符

成员运算符

in如果在指定的序列中找到值返回True, 否则返回Falsenot in如果在指定的序列中找到值返回False, 否则返回True

身份运算符：用于比较两个对象的储存单元

isis 是判断两个标识符是不是引用自一个对象. x is y类似于id(x) == id(y)is not与 is 相反

is 与’==‘的区别： is运算符判断的是同一性（两个对象是不是指向同一个地址），’= ='判断的是相等性；示例如下：

>>> r = 1

>>> id(r)

1834249248

>>> t = 1

>>> id(t)

1834249248

>>> r is t

True

>>> r = 1000

>>> id(r)

1716031387152

>>> t = 1000

>>> id(t)

1716031386096

>>> r is t

False

参考资料：《流畅的python》《Python》 python中的数字 python中字符串格式化的两种方法 python中map()的使用方法廖雪峰官方网站：@property的使用

[转载] python3.x总复习相关推荐

CISSP考前总复习
CISSP考前总复习转载于:https://blog.51cto.com/victorlau/59404
电分、模电、数电总复习之爱课堂题目概念整理
本文模电数电部分转载自博客园_模电数电爱课堂概念题整理模电.数电总复习之爱课堂题目概念整理电分总复习之爱课堂题目概念整理(原创)(不定期更新) 模电总复习之爱课堂题目概念整理 Chapter 1 ...
《线性代数》总复习要点、公式、重要结论与重点释疑
<线性代数>总复习要点.公式.重要结论与重点释疑查看全文 http://www.taodudu.cc/news/show-3196230.html 相关文章: 线性代数基础和英文表述[0 ...
穷吉201771010119总复习
实验十八总复习实验时间 2018-12-30 1.实验目的与要求 (1) 综合掌握java基本程序结构: (2) 综合掌握java面向对象程序设计特点: (3) 综合掌握java GUI 程序设 ...
Java总复习（二）
总复习 1.抽象类和接口 2.异常处理 3.Object类中的方法 4.类加载 5.String类 1.抽象类和接口接口和类是并列的结构抽象类接口区别 abstract修饰 interface ...
高等数学第七版-习题解答：总复习3
习题解答:总复习3 18*. 已知f′′(x)f''(x)f′′(x)存在,证明 lim⁡x→x0f(x0+h)+f(x0−h)−2f(x0)h2=f′′(x0)\lim_{x \rightarrow ...
大学不挂科c语言题库及答案,C语言期末总复习,保你不挂科!
C语言期末总复习总体上必须清楚的:- 1)程序结构是三种: 顺序结构 , 循环结构(三个循环结构), 选择结构(if 和 switch)- 2)读程序都要从main()入口, 然后从最上面顺序往下读 ...
负数比较大小_小升初总复习第七个基础模块：负数的认识
今天我们开始第七个基础模块的复习:负数的认识负数的认识一共分为3个知识考点. 第一,正负数的意义以前我们学过的6,10,7,85.....这样大于0的数叫做正数.正数前面也可以加"+& ...
计算机应用基础126题,2015-2016年全国计算机应用基础总复习.
20152015--2016年全国年全国计算机应用基础总复计算机应用基础总复习人的生命是有限的,但是为人民服务是无限的,我要把有限的生命投入到无限的为人民服务中去笔试分为四种题型:(1)单选题:( ...

[转载] python3.x总复习

[转载] python3.x总复习相关推荐

最新文章

热门文章