流畅的python视频讲解-学习--流畅的Python

colors = ["black", "white"]

sizes= ["S", "M", "L"]

tshirts= [(color, size) for color incolorsfor size insizes]

tshirtss= (("%s %s") % (color, size) for color in colors for size insizes)print(tshirts)for i intshirtss:print(i)

symbols= "$¢£¥€¤"codes= [ord(symbol) for symbol insymbols]

c= tuple((ord(symbol) for symbol insymbols))print(codes)print(c)

t= (20, 8)print(divmod(*t))

a, b,*c = range(5)print(a,b,c)

fmt= "{:}".format(12323)print(fmt)print("{:^14}".format("陈某某"))print("{:>14}".format("陈某某"))print("{:<14}".format("陈某某"))print("{:*<14}".format("陈某某"))print("{:&>14}".format("陈某某"))#填充和对齐^<>分别表示居中、左对齐、右对齐，后面带宽度

print("{:.1f}".format(4.234324525254))print("{:.4f}".format(4.1))print("{:.2f}".format(4.2222326))print("{:^12}".format("阿斯蒂芬"))print("{:o}".format(250))print("{:,}".format(100000000))print("{:,}".format(235445.234235))print("{名字}abc{性别}".format(名字="曾智超",性别="男"))print("{0}abc{1}".format("曾智超","男"))#具名元组

importcollections

City= collections.namedtuple("City", "name country population coordinates")

tolyo1= City._make(("Tokyo", "JP", 36.933, (35.689722, 139.691667)))print(tolyo1._asdict())

tokyo= City("Tokyo", "JP", 36.933, (35.689722, 139.691667))print(tolyo1)print(tokyo)print(tokyo.coordinates)print(City._fields)#切片赋值

l = list(range(10))print(l)

l[2:5]=[2, 2, 2]print(l)del l[2:5]print(l)

l[3::2] = [9,8]print(l)

l[2:5] = (100,100) #如果被赋值的对象是一个切片，那么赋值必须是一个可迭代的对象，即便是一个单独数值，也应变为可迭代序列

print(l)#对序列使用+ 和 *

l = [[1,2,3,"abc"],[4,5,6]]

l= 3*lprint(l)

l[0][1]="X"

print(l)#序列的增量赋值 *= 、+=(__iadd__) 可变序列上面一般实现了__iadd__方法，不可变序列上则没有

defp(x):return print(x)

l= [1, 2, 3]

p(id(l))

l*= 2p(id(l))

p(l)

l= (1, 2, 3)

p(id(l))

l*= 2p(id(l))

p(l)#+=谜题

t = (1, 2, [30, 40])

t[2].extend([50 ,60])print(t)importdis

p(dis.dis("s[a] += b"))"""Tips:

不要将可变对象放入元组中

查看Python的字节码

增量赋值不是一个原子操作"""

#2.7 list.sort方法和内置函数sorted

"""返回None来表示就地进行的改变（list.sort）

sorted新建一个列表作为返回值"""fruits= ["grape", "rasphberry", "apple", "banana"]

p(sorted(fruits,key=len))

p(fruits)

list.sort(fruits)

p(fruits)#2.8 用bisect来管理自己已排序的序列

importbisectimportrandomdef grade(score, break_score=[60, 70, 80, 90], grades="FDCBA"):returngrades[bisect.bisect_right(break_score, score)]print([grade(score) for score in [83, 92, 100, 50, 30, 72]])

SIZE= 7random.seed(1)

my_list=[]for i inrange(SIZE):

new_item= random.randrange(SIZE*2)

bisect.insort(my_list, new_item)print("%2d ->" %new_item, my_list)#当列表不是首选时，比如存放一个只包含数字的列表，数组可能是个好的选择

importarrayimportrandom

data= array.array("d", (random.random() for i in range(10**2)))print(data[-1])

fb= open("data.bin", "wb")

data.tofile(fb)

fb.close()

data2= array.array("d")

fp= open("data.bin", "rb")

data2.fromfile(fp,10**2)

fp.close()print(data2[-1])#Numpy和Scipy

importnumpy as np#data = np.loadtxt("data.txt",encoding="UTF-8")#print(data[-3:])

#使用deque

from collections importdeque

p= range(10)print(p)

data= deque(range(10),maxlen=10)print(data)

data.rotate(3)print(data)#字典(dict)和集合(set)

importcollections

my_dist={}print(isinstance(my_dist,collections.abc.Mapping))"""什么是可散列类型

一个对象是可散列的，在对象生命周期中，散列值是不变的！

需事先实现__hash__()和__qe__()方法，两个散列对象如果相等，得到的散列值是一样的

Python中不可变类型都是可散列的

映射的key只能是可散列的"""a= dict(one=1, two=2, three=3)

b= {"one":1, "two":2, "three":3}

c= dict({"one":1, "two":2, "three":3})

d= dict([("one", 1), ("two", 2), ("three", 3)])

p= zip(["one", "three", "two"], [1, 3, 2])

e=dict(p)print(a==b==c==d==e)#字典推导 dictcomp

D_CODES = [(86, "China"), (91, "India"), (1, "United States"), (62, "Indonesia"), (55, "Brazil"),

(92, "Pakistan"), (880, "Bangladesh"), (234, "Nigeria"), (7, "Russia"), (81, "Japan")]

p= {code:country for code, country in D_CODES} #字典推导式

print(p)print(dict(D_CODES))

q= {country.upper():code for code, country in p.items() if int(code)<64}print(q)#my_dist.setdefault(key,[]).append(new_value)#映射的弹性查询 1.利用defaultdict 2.自定义dict子类，重写__miss__()方法

classStrKeyDict0(dict):def __missing__(self, key):ifisinstance(key, str):raiseKeyError(key)returnself[str(key)]def get(self, key, default=None):try:returnself[key]exceptKeyError:returndefaultdef __contains__(self, key):return key in self.keys() or str(key) inself.keys()

a= StrKeyDict0({"one":1, "1":1, "2":"two"})#字典的变种

collections.OrderedDict #添加键的时候会保持顺序，删除的时候会删除末尾也就是最后一个加入的元素

collections.ChainMap

p= collections.Counter("aaabbbcccddewffjjll")print(p)

p.update("aaa")print(p)

collections.UserDict#让用户来写dict的子类的！~

#不可变映射类型

from types importMappingProxyType

pi= {"A":65}

pi_proxy=MappingProxyType(pi)print(pi_proxy)#pi_proxy["B"] = 66

pi["B"] = 66

print(pi_proxy)

p= frozenset(range(10))

q= set(range(10))print(p)print(q)#集合操作

p = {i for i in range(10)}print(p)

DIAL_CODES= [(86, "China"),(91, "India"),(1, "United States"),(62, "Indonesia"),(55, "Brazil"),

(92, "Pakistan"),(880, "Bangladesh"),(234, "Nigeria"),(7, "Russia"),(81, "Japan"),]

d1=dict(DIAL_CODES)print("d1:", d1.keys())

d2=dict(sorted(DIAL_CODES))print("d2:", d2.keys())print(d1 ==d2)#人类使用文本 计算机使用字节序列

s = "café"

print(len(s))

b= s.encode("utf-8") #用utf-8将str对象编码成bytes对象

print(b)print(len(b))print(b.decode("utf-8"))

p= bytes.fromhex("31 4B CE A9") #解析十六进制，构建二进制序列

print(p)

p= bytes("café",encoding="utf-8")print(p)

cafe_crr=bytearray(p)print(cafe_crr)print(cafe_crr[-1:])importarray

numbers= array.array("h", [-2, -1, 0, 1, 2]) #短整数16位

octets =bytes(numbers)print(octets)#结构体和内存视图#coding: cp1252

print("Olá, Mundo!")

u16= "El Niño".encode("utf_16")print(u16)print(list(u16))

u16= "El Niño".encode("utf_16le")print(u16)print(list(u16))

fp= open("cafe.txt", "w", encoding="utf-8") #open采用文本模式，返回一个TextIOWrapper对象

print(fp)

fp.write("café")

fp.close()importosprint(os.stat("cafe.txt").st_size) #UTF-8 编码的 "é" 占两个字节

fp2 = open("cafe.txt")print(fp2)print(fp2.read())

fp3= open("cafe.txt", encoding="utf_8")print(fp3)print(fp3.read())

fp4= open("cafe.txt", "rb") #在二进制模式中读取文件, 返回BufferReader对象

print(fp4)print(fp4.read()) #返回对应的字节序列

importsys, locale

expressions= """locale.getpreferredencoding()

type(my_file)

my_file.encoding

sys.stdout.isatty()

sys.stdout.encoding

sys.stdin.isatty()

sys.stdin.encoding

sys.stderr.isatty()

sys.stderr.encoding

sys.getdefaultencoding()

sys.getfilesystemencoding()"""my_file= open("dummy", "w")for expression inexpressions.split():

value= eval(expression) #eval将str当做表达式求值并返回结果

print(expression.rjust(30), "->", repr(value)) #repr返回一个对象的string格式

#s1 = "café"s2= "café"

print(s1, s2)print(len(s1), len(s2))print(s1 == s2) #不同的码位序列

from unicodedata importname

micro= "μ"micro_cf=micro.casefold()print(name(micro))#对非ASCII码排序使用的是 local.strxfrm 函数

fruits = ["caju", "atemoia", "cajá", "açaí", "acerola"]print(sorted(fruits))importlocale#locale.setlocale(locale.LC_COLLATE, "pt_BR.UTF-8")

sorted_fruits = sorted(fruits, key=locale.strxfrm)print(sorted_fruits)#PyUCA 使用Unicode排序算法排序

deffactroial(n):"""return n!"""

return 1 if n < 2 else n*factroial(n-1)print(factroial(42))print(factroial.__doc__)print(type(factroial))

help(factroial)print(list(map(factroial, range(6))))print([factroial(n) for n in range(6)])print(list(map(factroial, filter(lambda n : n%2, range(6)))))print([factroial(n) for n in range(6) if n%2])print(all([1, 1, 1]))print(any([0, 1, 1]))

fruits= ["strawberry", "fig", "apple", "cherry", "raspberry", "banana"]print(sorted(fruits,key=lambda a:a[::-1]))print(str,abs,123)print([callable(n) for n in [str,abs,123]])#用户定义的可调用类型

importrandomclassBingoCage:def __init__(self,items):

self._items=list(items)

random.shuffle(self._items)defpick(self):returnself._items.pop()def __call__(self, *args, **kwargs):returnself.pick()

p= BingoCage(range(6))print(p._items)print(p.pick())print(p())print(dir(factroial))#从定位参数到仅限关键字参数

def f(a, *, b):return(a, b)print(f(1, b=2))"""为什么引入激活函数

答：如果不用激活函数，很容易看到每一层的输出是上一层的输入的线性函数，那么

多层的隐含层就没有实际的效果，容易看到多层隐含层后得到的输出与单个隐含层得

到的输出是一样的，也就没有了深层网络的意义。"""

#函数注解 作用：为IDE和lint程序等工具中的静态类型检查功能提供额外的类型信息

def clip(text:str, max_len:"int > 0"=80) ->str:"""在max_len前面或后面的第一个空格处截断文本"""end=Noneif len(text) >max_len:

space_before= text.rfind(" ", 0, max_len)if space_before >=0:

end=space_beforeelse:

space_after= text.rfind(" ", max_len)if space_after >=0:

end=space_afterif end is None: #没找到空格

end =len(text)returntext[:end].rstrip()print(clip.__annotations__)from inspect importsignature

sig= signature(clip) #返回Signature对象

print(sig.return_annotation)print(type(sig.parameters))for i insig.parameters.values():print(type(i)) #参数名映射到Parameter对象

note = repr(i.annotation).ljust(13)print(note, ":", i.name, "=", i.default)#支持函数式编程的包