邂逅感！我觉得吧，挺好的，自己啃书就像是做预习，看视频教程就像是上课，在预习中遇到很多的问题，或者说预习后觉得自己都掌握了，又或者说，预习是平面学习，觉得都重要。
但在课上时，就会发现原来老师的思路是这样的，这些是关键或是主体，哦，这些是我没有注意过的，等等！
于是这次看小甲鱼的教程，倍速看，也没觉得落下什么，而且还捡起了好多细节知识，而且还思考了如果这样那样写的话，会怎样，总之看到了第19P，自定义函数.__doc__，书上没出现过的，我大概也没看到过的只是部分，于是又要回到啃文档上，教材、文档、教程的循环！
P4 字符串的赋值写法r"\""\"
In [18]: print(r"\\")
\\
In [19]: print(r"c\")
File "<ipython-input-19-987bd18403e7>", line 1
print(r"c\")
^
SyntaxError: EOL while scanning string literal
In [20]: print(r"c\\")
c\\
In [21]: print(r"c\\\")
File "<ipython-input-21-904397e50c05>", line 1
print(r"c\\\")
^
SyntaxError: EOL while scanning string literal
In [22]: print(r"c\\\\")
c\\\\
今天来店里，于是啥都没有，就看小甲鱼吧，里面说到我之前查了好久才查到的一些问题的答案，于是小甲鱼的视频加入到我的教材中，他里面有句话，r""不能用\结尾。
思考不出来大佬们怎么想的，一个遗漏的bug还是有其他原因。看来两个\可以看作一组，能在r""中，甚至结尾出现，但是奇数的\就不行了！
In [24]: print(r"c\\""\\")
c\\\
In [29]: print("c\\" "a\\")
c\a\
165 µs ± 2.64 µs
In [30]: print("c\\","a\\")
c\ a\
239 µs ± 4.28 µs
In [31]: print("c\\"" a\\")
c\ a\
167 µs ± 2.9 µs
In [50]: "a""b"
Out[50]: 'ab'
嗯，一直以为print内的字符串需要用逗号连接，还能这样写。
奇妙，因为书中都是用一对双引号前后括注，所以从未思考过这个问题，但这个也只是奇淫巧计而已，因为这个只能是两个字符串间的操作，既然可以直接连起来，为何还。因为双引号和单引号吧！？
In [55]: print(r"a"r"b")
ab
P4字符串写法
In [2]: a=r"123\\""\\"
In [3]: a
Out[3]: '123\\\\\\'
In [4]: print(a)
123\\\
In [5]: print("a" "b")
ab
In [7]: print("a"+a+str(123))
a123\\\123
P6 e
e是float的表示方式之一，所以赋值时用e，变量就是float。长串数字带小数点，仅有print将变量作为一个单独的目标处理，即无其他变量或变量前后有逗号。
In [19]: a=15000000000000000000000000000000000000000
In [20]: a
Out[20]: 15000000000000000000000000000000000000000
In [21]: a=15000000000000000000000000000000000000000.0
In [22]: a
Out[22]: 1.5e+40
In [23]: print(a)
1.5e+40
In [24]: print("{}".format(a))
1.5e+40
In [25]: print("%f"%a)
15000000000000001060141952447820087689216.000000
In [38]: str(a)
Out[38]: '1.5e+40'
In [39]: print("%s"%a)
1.5e+40
其实单独逗号的变量是独属于一次print处理的：
print(a);print(a)
343 µs ± 4.84
print(a,a,sep="\n")
342 µs ± 3.95 µs
print("{0}\n{1}".format(a,a))
269 µs ± 1.32 µs
P6 True + True
In [34]: True
Out[34]: True
In [35]: True +True
Out[35]: 2
In [36]: True + False
Out[36]: 1
小甲鱼说不要这样做，但之前一个网友在评论中的作业，判断设置的密码等级如何。数字、字母、符号。虽然也有密码长度的判断吧，但关键的是这里：
仅有数字和字母其中一项，密码等级一
同时有数字、字母、符号其中两项，密码等级二
三项，密码等级三
如果判断的结果仅调用一次，即不需要调用多次而先赋值给一个变量甚至生成多个变量。那么我们直接调用其结果相加，岂不妙哉？
P7 int(float) 截断处理
P7 str=123
In [41]: str=121
In [42]: str=123
In [44]: a=0.123
In [45]: c=str(a)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-45-e8e9f0564cab> in <module>
----> 1 c=str(a)
TypeError: 'int' object is not callable
不能被赋值的仅有几个常量
In [47]: True=1
File "<ipython-input-47-cd027a99ded3>", line 1
True=1
^
SyntaxError: cannot assign to True
In [1]: temp=str
In [2]: type(temp)
Out[2]: type
In [3]: str=123
In [4]: str=temp
In [5]: str(123)
Out[5]: '123'
之前看过怎么设置help到文件，等操作，用的就是temp将type临时存放
那到底如何在str已被破坏的情况下，重新赋值呢？
P8 -10//4
In [3]: -10//4
Out[3]: -3
P8 -3**2
In [5]: -3**2
Out[5]: -9
P8 优先级
**
+1 -1
* / %
+ -
< <= >= > == !=
not and or
In [13]: -1**2
Out[13]: -1
In [18]: 2**-1
Out[18]: 0.5
In [6]: not 1 or 1
Out[6]: 1
In [7]: not 1 and 1
Out[7]: False
In [8]: 1 or 1
Out[8]: 1
In [9]: 1 or 4
Out[9]: 1
In [10]: 4 or 1
Out[10]: 4
In [11]: 1 and 5
Out[11]: 5
P9 三元操作符
此简写是python之父应对用户需求而写的
In [1]: %%timeit
...: x,y=4,5
...: if x<y:
...: small=x
...: else:
...: small=y
...:
73.7 ns ± 0.978 ns
In [2]: %%timeit
...: x,y=4,5
...: small=x if x<y else y
...:
...:
77.9 ns ± 1.78 ns
结果1 if bool else 结果2
当bool为True时，为结果1，反之，为结果2
效率：
In [16]: %%timeit
...: if True:""
...: else:""
...:
...:
14.1 ns ± 0.0933 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [17]: %%timeit
...: if False:""
...: else:""
...:
...:
14.2 ns ± 0.119 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [18]: %%timeit
...: "" if True else ""
...:
...:
26.4 ns ± 0.549 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [19]: %%timeit
...: "" if False else ""
...:
...:
33.1 ns ± 0.708 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
效率：原始True>=原始False>>三元True>>三元False
P10 断言 assert
In [45]: a=1;b=2
...: c="吾辈是只喵"
...: #我叫你一声毛猴，你敢答应不？
...: assert a>b,c
...: print("a>b很真理")
---------------------------------------------------------------------------
AssertionError Traceback (most recent call last)
<ipython-input-45-6f4f78c88ba8> in <module>
2 c="吾辈是只喵"
3 #我叫你一声毛猴，你敢答应不？
----> 4 assert a>b,c
5 print("a>b很真理")
AssertionError: 吾辈是只喵
assert是一个debug用语句，但处于一个关键节点时，使用assert判断数据，如果错误，报错，报错内容为assert的可选参数，参数（变量等），将其前后共四句抛出，并有记录第几行
而在程序debug无bug后：
python -O 禁用assert
python -O -m “File” 编译源代码，不包含assert语句
220字节 不包含assert语句的编译文件大小
254字节 包含assert语句的编译文件大小
C:\Users\John>python "D:\win7\Documents\python\20200707 assert.py"
Traceback (most recent call last):
File "D:\win7\Documents\python\20200707 assert.py", line 4, in <module>
assert a>b,c
AssertionError: 吾辈是只喵
C:\Users\John>python -O "D:\win7\Documents\python\20200707 assert.py"
a>b很真理
C:\Users\John>python -O -m py_compile "D:\win7\Documents\python\20200707_assert.
py"
C:\Users\John>D:\win7\Documents\python\__pycache__\20200707_assert.cpython-38.op
t-1.pyc
a>b很真理
C:\Users\John>python -m py_compile "D:\win7\Documents\python\20200707_assert.py"
C:\Users\John>D:\win7\Documents\python\__pycache__\20200707_assert.cpython-38.py
c
Traceback (most recent call last):
File "D:\win7\Documents\python\20200707_assert.py", line 4, in <module>
assert a>b,c
AssertionError: 吾辈是只喵
P10 a,b=1,2 PASS
“” ‘’ pass，个人认为效果是一样的，而效率也差不多
而a,b=1,2（53vs33），与三元操作符一样，效率都是较低的。个人认为，这都不是原生语言，而是宏，所以效率低。他们都需要解析成原生语言的结构才进一步运算，即便他们已经编程为机器码，也免不了转成原生结构！
14.2 ns ± 0.162 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [23]: %%timeit
...: ""
...:
...:
14.2 ns ± 0.113 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [24]: %%timeit
...: ''
...:
...:
14.3 ns ± 0.321 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [25]: %%timeit
...: pass
...:
...:
14.6 ns ± 0.83 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [26]: %%timeit
...: a,b=1,2
...:
...:
53.1 ns ± 0.51 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [27]: %%timeit
...: a=1
...: b=2
...:
...:
33.1 ns ± 0.0709 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [28]: %%timeit
...: a=1;b=2
...:
...:
33.3 ns ± 0.0634 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [29]: %%timeit
...: a=b=1
...:
...:
32.5 ns ± 0.384 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
while for 效率
In [52]: %%timeit
...: i=0
...: while i<1000:
...: i+=1
...:
81.8 µs ± 4.09 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [53]: %%timeit
...: for i in range(1000):
...: ""
...:
29.4 µs ± 561 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)```
## list=[变量]
```python
In [54]: a="uncle wang"
In [55]: l=[a]
In [56]: l
Out[56]: ['uncle wang']
In [60]: l=[yikesaiting]
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-60-23f5efa4d514> in <module>
----> 1 l=[yikesaiting]
NameError: name 'yikesaiting' is not defined
P12 列表的创建、插入、删除
iterable：数组（列表、元组、range()，字符串、集合等），切片，map
list(iterable)
[数值，变量，等等]
list.insert(索引，数值)
list.append(数值)
list.extend(iterable)
list.remove(数值) 仅删除遇到的第一个数值
del list[索引/切片/步进等]
del list
list.clear()
insert(self, index, object, /)
Insert object before index.
我之所以看书发蒙，就是因为在组合数据中突然冒出四个组合数据，实际上文档中说了更多更多的数据类型。而每个数据类型有很多很多的方法，实际上要比书上讲的那些多很多。而且例子很无语的说，所以一下子进入了停滞、整理、重学的状态。数据繁杂，教材无序，内容深！
不得不说小甲鱼讲的让人没压力，没顾虑，所以学习还是需要个可以信赖的老师的，书本太死了！
P13 list1=list2+list3
In [1]: list1=[1,2,3]
In [2]: list2=[4,5,6]
In [3]: list3=list1.extend(list2)
#list1.extend(list2) 是执行操作，不是返回操作
In [4]: print(list3)
None
In [5]: list3=list1+list2
In [6]: list3
Out[6]: [1, 2, 3, 4, 5, 6, 4, 5, 6]
P13 dir(list)
其实知道，但是不常用，但为啥看小甲鱼用就这么羡慕呢
P13 list.sort(reverse=True)
In [1]: list1=[0,3,1,6,9,5,2,8,7]
In [2]: %%timeit
...: list1.sort()
...:
...:
173 ns ± 0.0687 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [3]: %%timeit
...: list1.sort(reverse=True)
...:
...:
279 ns ± 0.359 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [4]: %%timeit
...: list1.reverse()
...:
...:
81.3 ns ± 0.234 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
于是，这是一个宏！
P13 list1=list2[:]
等同于 list1=list2.copy()
In [7]: type(list1)
Out[7]: list
In [8]: type(list1.copy())
Out[8]: list
In [9]: type(list1[:])
Out[9]: list
In [10]: type(list1.reverse())
Out[10]: NoneType
P14 tuple1=() =1, =1,2,3
P14 tuple1=tuple1*8
P14 tuple1=tuple1[:5]+(数值，)+tuple[5:]
“{{{{{}}}”.format(1)
In [35]: "{{{{{}}}}}".format(1)
Out[35]: '{{1}'
在格式化状态下，"{{“表示”{"，类似于"\\“表示”\"
“熊大”>“熊二” unicode_escape、UTF-8
In [43]: "熊大">"熊二"
Out[43]: True
In [44]: "熊大"<"熊二"
Out[44]: False
In [45]: ord("大")
Out[45]: 22823
In [46]: ord("二")
Out[46]: 20108
In [47]: chr(22823)
Out[47]: '大'
In [48]: chr(22824)
Out[48]: '夨'
In [49]: chr(22825)
Out[49]: '天'
InIn [50]: "熊大">"熊天"
Out[50]: False
In [51]: hex(ord("大"))
Out[51]: '0x5927'
In [55]: "大".encode(encoding="unicode_escape")
Out[55]: b'\\u5927'
In [57]: "大".encode(encoding="UTF-8")
Out[57]: b'\xe5\xa4\xa7'
于是，ord、chr等字符与二进制转换是以unicode为编码的。
但，有一个要注意，UTF-8编码是脚本的原生编码，如果将代码文件保存为unicode，直接报错：无法读取文件。
而保存为GBK等编码，需要在第一行注释，# -*- coding:GBK -*-，前提是，python能读懂第一行的话！或者说我并没有正确的写出unicode的编码的第一行。
sum(iterable, /, start=0)
sum (iterable, /,开始= 0)
返回一个“start”值(默认为0)加上一个可迭代的数字的和
当可迭代为空时，返回起始值。
这个函数是专门用于数值的
拒绝非数字类型。
sum(iterable，numbers)
sum(list/tuple/set/range,int/float/complex)
In [35]: sum((1,2,3,4),10)
Out[35]: 20
In [38]: sum("",10)
Out[38]: 10
#虽然""是字符串的标示，但这里同样可以表示空iterable
sorted(list) vs list.sort()
587:376
sorted(iterable, /, *, key=None, reverse=False)
返回一个新的列表，其中包含来自iterable的所有项目，并按升序排列。
可以提供自定义键函数来定制排序顺序和
反向标志可以设置为按降序请求结果。
list.sort(self, /, *, key=None, reverse=False)
.sort是list专署的，两者返回的都是列表，所以tuple都无法使用！
sorted vs reversed 结果 vs 标识
In [65]: l
Out[65]: [1, 2, 3]
In [66]: sorted(l)
Out[66]: [1, 2, 3]
In [67]: sorted(l,reverse=True)
Out[67]: [3, 2, 1]
In [70]: reversed(l)
Out[70]: <list_reverseiterator at 0x44a9d00>
In [72]: type(sorted(l))
Out[72]: list
In [73]: type(reversed(l))
Out[73]: list_reverseiterator
In [82]: t
Out[82]: (4, 5, 6)
In [83]: reversed(t)
Out[83]: <reversed at 0x4da2820>
In [85]: type(reversed(t))
Out[85]: reversed
sorted是个需要运算的步骤，所以他是一次次的导出结果，这个结果需要保存的地方，于是干脆就把这个最终的结果给出来了。
而reversed是一个很简单的运算，在我目前学到的知识来说，我无法看到他的源码，我只能逻辑推测：
In [91]: t
Out[91]: (4, 5, 6, 4, 5, 6, 4, 5, 6)
In [104]: %%timeit
...: list(t)
...:
...:
375 ns ± 0.646 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [105]: %%timeit
...: reversed(t)
...:
...:
287 ns ± 0.111 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [106]: %%timeit
...: list(reversed(t))
...:
...:
1.18 µs ± 1.61 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [108]: %%timeit
...: tuple(reversed(t))
...:
...:
1.13 µs ± 7.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [109]: %%timeit
...: tuple(reversed(t))
...:
...:
1.11 µs ± 1.04 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [110]: t=t*1000
In [111]: %%timeit
...: list(t)
...:
...:
25 µs ± 7.7 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [112]: %%timeit
...: reversed(t)
...:
...:
288 ns ± 0.196 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [113]: %%timeit
...: tuple(reversed(t))
...:
...:
418 µs ± 481 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
被reversed的对象长度并没影响reversed的时间，于是推测，reversed只是个标记，标志着这里有个运算，如果有可转化其运算为：
| reversed(sequence, /)
|
| Return a reverse iterator over the values of the given sequence.
iterable的，操作对象是序列，操作内容为标识，遇到特定可转化类型，才会激发运算。
reversed enumerate zip
enumerate：ex nume(ral) rate 拿出数字的序列，枚举
In [117]: enumerate(t)
Out[117]: <enumerate at 0x51044a8>
In [118]: %%timeit
...: enumerate(t)
...:
...:
410 ns ± 1.36 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [119]: %%timeit
...: list(enumerate(t))
...:
...:
1.39 ms ± 15.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [120]: %%timeit
...: zip(range(len(t)),t)
...:
...:
1.4 µs ± 28.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [121]: %%timeit
...: range(len(t))
...:
...:
833 ns ± 17 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
