python summary（for previous 6 weeks）

 

3.19和3.20  上课总结：

1. 冯诺依曼体系：计算机的基本硬件系统。

 

输入设备               内存器                    输出设备

 

CPU（处理器 ，运算器， 寄存器 和多级缓存）

 

注意（数据流，是先进入内存器，再到CPU，CPU处理完后再到输出设备。这就导致了处理数据速度的差异，CPU中的数据处理速度快于内存，内存快于磁盘等。而在CPU多级缓存中，一级缓存的速度快于二级缓存，以此类推。）

 

2. python是一门解释型的动态的高级语言。

动态：不提前规定类型，直接赋值。

解释型代码，先换成中间代码bytecode,再在虚拟机上运行。

 

3. 编程： 算法 +数据结构

算法：是数据如何计算

数据结构： 数据在内存中如何放。

4. Python 的解释器

Cpython是c语言开发的，是python的官方解释器。

Ipython 是一种交互式的解释器

Jpython 是一个由Java开发的，跑在Java虚拟机上的字节码

Pypy 应用动态编译技术.

5. Python的基础语法

数字的类型：整数int

进制binary  二进制

Oct     八进制

Hex     16进制

浮点数 float

复数  complex

布尔值  bool（true  false）

6. 字符串

用‘’  或者“” 表示字符串；

‘’‘ ’‘’‘   “”“  “”“   使用三个单双引号可以任意在里面使用单双引号、换行等。

关注‘‘’ ‘’‘  和“”“ ”“”  的用法，里面的单双引号一级各种转义符可以直接用。

上图感受‘’‘ ’‘’‘ 和“”“ ”“” （三引号）的强大之处，只要在三引号里面，所有的转义号都不再需要。要换行直接enter键，要加单双引号直接加，然后在jupyter中要记得print，要不然只会输出其源码。

没有三引号的，用单引号或双引号引用字符串的。

用转义符和其符号：

\n 换行    \t空格键      \\ 斜杠

\’ 单引号       \”双引号

特殊的：r放在最前面，“ ” ‘ ‘ 内的所有转义都不再起作用。

‘‘’ ‘’‘行位用\，则可以续行

7. 标识符（一般用字母开头，注意 大小写敏感型）
8. 再次强调 python是一门强类型、动态的解释型语言。
9. 运算符：

 

算术运算：

+  –

a/b             a除以b

a*b             a乘b

a**b            a的b次方

a//b （整除）   a整除b,只取商的整数部分

a%b （取模）    a除b 取余

 

位运算：           都先转化成二进制

位与         &      （都为1才得1，其他得0）

位或          |      （有1即得1，其它都为0）

位异或       ^      （两个位不同才得1，其它为零）

按位取反     ~       ~x  =  -(x+1)

 位左移      >>       8>>2    为2    也可以 8/ (2的平方)

位右移      <<       6<<2    为24  也可以按6*（2的平方）

（箭头的尖  就是位移动的方向）

10. 原码（写成二进制格式：9 ==> 0b1001），反码，补码2

正数：

原码，反码，补码都是其本身

负数：

原码： 符号位为1。   例：-1 原码：1000 0001

      反码：符号位不变，其余按位取反。

                            例：-1反码：1111 1110

      补码：符号位不变，其余按位取反后加1

                            例：-1的补码 1111 1111

 

负数真正在计算机中按补码储存。 负数的补码就是其反码加1.

 

11. 运算符：

算术运算符和位运算符。

 

比较运算符：

==   是否等于

！=   是否不等于

<     小于                      >   大于

>=    大于等于                 <=   小于等于

 

逻辑运算符：

与 and

或  or

非  not

短路运算符(在逻辑运算符中说的)：

and中，如果第一个表达式错了。那这个表达式就错了。

Or中，如果第一个表达式对了。那这个表达式就对了。

 

赋值运算：

+=   -=  /=  *=   %=

A= min (1,4)   max

成员运算：in ，   not in

 

 

身份运算：is ，   not is

总结7种运算符

1. 算术运算符

+ ，-， * ，/ ，//，%， ** 。

2. 位运算

&，|，^，~，>>(位右移)    <<(位左移)

3. 比较运算

==，！=，>，<, >=，<=

4. 逻辑运算

and   or  not

注意and 和or的短路运算

5. 赋值运算

+=，-=，、/=，*=，%=、

a = min(1,7)  max

6. 位置运算

In  ，not in

7. 身份运算

Is  ，not  is

 

GC用 引用计数的 规则

不要随便用GC(garbage collection) 垃圾回收机制

 

单支循环：

If 条件句后面必须是一个bool型，所以会涉及到一个隐形转换的过程。

真值表：所有空的，只要是空，比如：0，空字符串“ ”，空列表[ ]，空元组( )，空字典{ }，None （常见的6种假）对应于bool型都是false。

If cond:

Block

注意：if后面的条件必须是bool型。然后冒号： 。

执行条件缩进，形成语句块

分支循环：对一个条件的判断，比如输入一个number，是大于零，小于零，还是等于0.这三个if条件在同一个竖直位置上。

分支嵌套循环：对分支结构的加深理解。

自己存在的喜欢问题：

1. if condition后面不加冒号： 2 f后面也有条件句用来判断
2. if后面加bool型条件，所以只走其中一个分支。只要走其中一个，其余的都不会进行。Print要输出语句，要加“”号，变量的一致性。（>>>）输入提示符。Len函数的对象是一个字符串。

例：给定一个不超过五位的正整数，判断其有几位：

While循环

For 循环

 

Break

Continue

 

 

 

 

2.

 

 

 

打印正方形

求100以内偶数的和：

1到5阶乘之和

二、函数的内置数据结构

数值型：int，float，complex，bool

序列对象：字符串str      列表 list      tuple 元组

键值对：  集合set    字典dict

数字的处理函数：

round

floor

ceil

int

min

max

pow（x，y）           x的y次方

math.sqrt()             x开平方根

进制函数：   bin()   oct   hex

math.pi

math.e   自然常数

type函数

 

二．list：

1. 列表，quenue，stack 和链表的区别

List 可变：列表内的元素可以是任意一个对象，故也可以是一个列表。元素可以插入任意位置，也可以从任意位置拿走。

Quenue  队列 ：元素只能从最前面和最后取出

Stack 只能后进后出，类似摞盘子模型

链表：linked list   手拉手模型   是散落的元素

 

List,  quenue, stack ,linked list  是内存常见的数据结构 。

 

List  和 linked list  的区别是：

List是在内存空间中是连续的，而linked list 在内存中是散落的空间。

 

List可以当函数使用。List（）中必须是可迭代对象

可以迭代的：iterable

2. 列表的初始化

Lst=[ ]

Lst=list()

Lst=[1,2,3]

Lst=list(range(10))

3. list de 初始化过程：

lst=[ ]

lst=list()  new empty list

lst=list(iterable)  (括号中必须是一个可迭代对象）

new list initialized from iterables’ items

4. 列表的索引访问

Lst[index]  不能越界，否则会抛index error

列表的索引lst.index(元素，start，stop)

返回在lst中找到 该元素 对应的第一个索引值。

通过index函数，括号中是list的元素，最后输出元素对应的index值（偏移量）

中括号中是index值，找到该位置对应的元素。

 

5. 列表的查询‘

Lst.index(元素，开始的index，结束的index)

返回的是在（开始index，结束index）中元素第一次出现对应的index值。

只找在索引范围内的第一个元素值对应的index值

6. 列表元素的修改：

列表元素的修改是就地修改，返回值是none

 

7. 列表增加，插入元素

Lst.append()

lst.insert(元素，要插入元素所在的索引值)

append 和insert 最后都是就地修改，返回none，没有新的列表生成。

还有count（）函数。

返回列表中元素出现的的次数

列表的增加extend(iterable) ，就地修改，返回none 即没有生成新的列表。

 

列表的+：

生成新的列表，原列表不变，本质调用add函数

列表的*（列表的复制）

注意，在复制的时候a是一个元素，只是这个元素是一个列表，这样复制的才是一个引用，lst2的元素改变时，a中的元素也会改变。

 

Lst*(某个值)  和浅拷贝copy本质上是一样的

都是复制一个引用，改变某个元素时，别的元素也会改变。但保证复制的时候以一个元素来，只不过这个元素是一个包括几个元素的额列表

Deepcopy

 

和浅拷贝用法不同，

生成新的列表，切deep是copy模块下的类函数，用法是：copy.Deepcopy（需要复制的元素）

a.copy()   是浅拷贝的用法

深拷贝 复制的就是元素，生成新的列表。

元组：

元组的初始化：
t=tuple(iterable)

括号中必须是一个可迭代对象，可以是一个列表，也可以是一个元组。

含有一个元素的元组：

t=(1,) 必须有逗号，代表只有一个元素的元组

t.index(value,start,stop)    元组元素的索引

count（value）  元组中的元素不可以增删 改

namedtuple  的用法

冒泡法总结：

列表中确定某j项：如果从小到大排序，则和j+1项比较，如果lst[j]<lst[j+1]

则两者互换。   I的循环循环，遍历完lst中的元素。

字符串：

1. 用单引号，或双引号包起来
2. 转义符“\n” 换行

“\t”  空格

“ \” ”  引号

“ \’ ”  单引号

R 放在前面，所有的转义符号将不起作用

3. 三引号里面可以用任意符号。
4. 字符串的join函数： 注意格式：“string”.join( iterable)

注意：分隔符格式必须是字符串，可迭代对象中的元素也必须是字符串。

5. 字符串通过“+”连接。
6. Split 函数

Split(分隔符，maxsplit（分割的刀数）)

将字符串按 分隔符 分割成若干片段，然后返回含有字符串的列表。

注：分割的刀数maxsplit为x，则最终的片段数是(x+1)

按某个分隔符切割，分隔符将不存在于切开的片段中。

Split  默认是从左到右切割。   如果要从右到左，则用rsplit

splitlines ([keepends])    按照行号分割：\n   \r  \n\r

默认keepend 是False的，如果括号中写True时，即要保留行分隔符。

注意用\n  和\r  ,打印字符串时的区别。

Partition用法：必须有分隔符。

将字符串分割成三个元组：头，分隔符，尾巴。

三种分割方式的区别：split ，splitlines  partition

字符串的大小写：

upper 将所有字母都大写

lower  将所有字母都小写

swapcase   将大小写互换

title   将每个单词的首字母大写

capitalize   将句子的首字母大写

zfill（width）居右边，左边用zero 填充，指定宽度。

rfill（width, 填充符号）

lfill (width，填充符号)（左右对齐如果没有指定填充符号，默认用空格填充）

字符串的修改：

Replace（原来的字符串，要改成的字符串，更改次数）

注意：括号中的前两者一定要是字符串，【更改次数】不是必须参数。

Strip 的用法：

如果不指定字符，则去掉字符串左右两边的额空白字符。

如果指定字符，且用strip。 则去掉左右两边 指定中的字符。

Rstrip  只去掉啊右边的字符

Lstrip   去掉左边的字符

字符串的查找：

用  find（value，开始索引值，结尾索引值）

Rfind   从右边开始找

用index（）

用 count （）

以上三种时间复杂度都是O（n）

注意：  字符串中的value   一定是字符串形式，加引号的。

 

字符串的判断：

 

.endswith( )   是不是以某个字符结束（注一定是字符串）

.startswith()

Isalnum( )   是否是字母和数字组成

Isalpha()    是否是字母

Isdecimal()  是否只包含十进制的数字

Isdigit  是否全部是数字

Isidentifier   是不是字母和下划线开头的

Islower     是否全是小写

Isupper     是否全部是大写

Isspace      是否包含空白字符

Digit：特殊的单字节的属于digit

decimal，Numeric：

 

 

字符串的格式化： .

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

列表  线性（sequence）  可变 可以插入

链表 支持先进先出  后进后出

Stack 摞盘子模型

 

 

 

2018.3.26课程

列表习题

1. 求100以内的质数（质数也叫素数）

第一种方法用：一个合数肯定可以分解成多个质数相乘，所以质数的倍数肯定是合数。  

 

关注break的用法 ：第一个满足if 条件的，即：可以整除，不输出i，且后面的循环不在继续（在2到i开根号之间找到可以被i整除的第一个数j,就可以确定i是合数，i与(j,i**0.5)[不包括j]后面就不用再整除了），就用break。  

Continue的作用是：if i/j==0，contine。可以整除：不输出I,但i还要和j之后的直到（i**0.5）的值循环。（在2到i开根号之间找到第一个可以被i整除的j，接着往下找。上一题中找到第一个可以被i整除的j, 已经可以确定i是合数，而不用继续i与（2，i**0.5）中除了j 以外的数整除了，故用break）。

所以 break 和continue的区别就是：找到一个满足if条件的值后是否还要继续循环

2． 杨辉三角函数。

第一种方法：

  

 

 

 

 

 

 

 

 

 

 

2018.3.27课程

字符串

1. 一个个 字符 (不是字节)组成的有序的序列，单引号，双引号。

可迭代和可索引定义不同

2. 字符串是不可变对象

而字符串的加法是（把两个字符串拼接起来）重新定义一个新的字符串（没有改变原字符串）

Unicode  字符  UTF-8编码

r  (raw)  裸字符

字符串可以索引

基本的ANSII 码    换行 \n(linux ,mac)    \r \n  windows

在python3 中所有的字符都是UTF-8编码的

但在内存中  是Unicode。

字符串是可迭代对象（可索引，不可变）

map 函数  一一转换

用-把 sql中各个字符连接起来

字符串join的用法  “ ”.join( )

map函数转换类型map(a，b)把b类型转化成a类型

换行新法   用“\n”将多个元素连接起来

***

Join 连接的元素 类型必须为字符串类型，如果不同，用map函数转换。

3字符串的加减 乘

3. 字符串的分割

Split

 

Split里的参数为none或等价为none时：

Split（）：尽可能多的空白字符  来分割字符串

Split参数  不是none时 ：

Split（sep,maxsplit）   sep 分隔符   maxsplit  为最大分割次数

Rsplit  为倒着切

倒着切一刀，然后再做负索引。

Partition 函数 ：切一刀

Str. 函数Upper    调用str的upper方法

用户输入，然后可统一大小写。

Title  capltalize   center 函数

Format 函数。。。

字符串的修改。

为什么能修改：因为它返回一个新的字符串。

strip函数：默认情况下，去掉两边的空白字符

Strip（） 在左右两边 去除，凡是在字符集里的就去掉

Enumerate

 

Replace 函数

 

• * 冒泡排序法定义：（考排序和算法）

交换排序中最基本的算法

基本的排序方法：   冒泡排序 

 

2018.3.29

1.字符串的格式化

  Join函数（拼接的必须是 字符串类型的）

%03d   

占位符：

Precision （精度）

 

 

{ }  有冒号：意为开始限定格式。

format函数返回一个字符串

 

时分秒小写

前面是占位符后面是format函数

：后面的数字为宽度。点后面的为点为几位加“f”

区分：数字的精度，宽度和有效数字。

 

 

 

 

 

 

 

 

16:00

字符串和编码有关，字节和编码无关。

1. 定义：

Bytes：不可变的有序的字节序列

Bytearrary: 可变有序的字节序列

2. 对字符串进行编码：

a.encode() （意为对a进行编码encode，括号里没有值，则默认是用utf-8） 返回的是bites型，注意不是字符串。

2. 下面是对a986的bites进行解码（decode），用utf-8，输出是字符串。

b” ”.decode( )

从字符串到bytes是编码，从bites到字符串是解码过程。

ASCII

Unicode-8是便于网络传输的编码

字符串前面加b,就是字节byte。

Encode 编码   decode 解码

 

字符序列和字节序列

Bytearray 可以当做是byte的副本，只是bytearray可变。Byte 和bytearray（都是字节）与编码无关。

Byte和bytearray 只是内存中存储的字节序列

字节和数字相关     字符和编码相关

 

UTF-8 包括所有的ASCII 码

Bytearray 可变

后面的数必须是从0到255 内的数

Byte 很重要  和字符串对比

 

可以索引的数据结构：

列表，元组，字符串，bytes    bytearray

索引：下标  ，index

切片【 start，stop，step】如果start和stop都为负数，步数也应该是负的。默认是正轴向右增加。。

 

 

直接在lst这个对象上倒着数 ，而for c in range[::-1]中会相当于copy一个新对象。

所以要倒着打印，用reverse更高效，不占用内存。

 

 

 

 

 

 

 

 

例题：输入一个多位数，输出它的位数，输出它每一位数出现的次数，将它的每一位从最高到最低输出

 

 

 

 

 

2018.4.2  

 

上午将习题

 

练习讲解：

 

 

1. 阶乘

 

 

2. 转置矩阵

 

 

 

 

3．

 

 

 

 

 

Enumerate的用法：  列举

 

 

 

 

 

 

 

 

考点：

快速排序

矩阵: 二维  替换

交换排序：冒泡  bubble sort  

阶乘
冒泡排序：

 

 

 

 

 

 

简单快速排序：

 

 

简单排序法的优化：

 

 

优化方法1：  最大值和最小值同时找，那比较次数就会折半。   #  二元排序法

 

 

优化方法2：特殊列表  

           【1,1,1,1,1,1,1,3】

第一趟下来：【3,1,1,1,1,1,1,1】

          当lst【maxindex】=【miniindex】时，说明中间有相同的值。。。

 

冒泡排序法的优化是加flag

 交换排序：      冒泡排序     (时间复杂度为n平方)

 选择排序：      简单排序法    （时间复杂度n 平方）

 

 选择排序的性能优于交换排序，因为交换排序 替换次数减少 。

 

 

 

Dict

 

 

 

 

 

4.2号  16点课程：     字典很重要

  列表list

  集合

  字典     非常重要的数字结构

  初始化：d ={ }  (和set空集合的比较)

          d= dict( )    内部的必须是键值对     二元结构

 Key=》value    字典里必须是键值对，两个键值对之间用逗号隔开

字典得无序体现在key的无序，

set的无序体现在元素的额无序。

没有d.pop()   ,因为dict是无序的，pop 没有参数的话，是从尾部弹出，而dict没有尾部。所以不正确

 

 

Del 语句：

删除的究竟是哪个

Get  得到   缺省值

字典迭代过程中  不能增删元素   

 

 

比下来有最大值，固定在某一个位置。  

 

 

 

迭代过程中不允许改变字典size（比如增删元素），用如下方法。

 

 

 

 

 

 

 

有序字典   ordereddict

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2018.4.3 

昨天习题

 

第二个题:

 

 

 

 

 

第三题：

 

 

一个东西出现多少次： 用字典。 累加。。列表，字典。

去重，用set。

 

生成随机数据的一般用法。

Sorted 函数，如果类型不同，加key值。

 

字典中按item  和key排序。。

 

 随机取出字符串的三种方法。

按key排序

按value排序

新课：

Python的解释器和生成器。

Import datetime

datetime.datetime()   第二个datetime 是一个类

 

 

datetime.datetime.(重要的是格式化和timedelta)

datetime下有datetime 和timedelta

 

第一个是调入函数。第二个是类、strptime 是类下的方法。

 

时间对象 +- 时间变量对象  

 

 

 两者不同

列表解析式：  迭代的时候由【 】不断收集每次算出的结果

 

和上面的第一个进行比较。下面list后面加的是一个可迭代对象。上面sorted中是一个对象

【 】等价于for循环中的append 

第一个print输出（range10）。而【】将其中print（i）回的none组合成列表

 

 

 

 

 

列表解析式打印九九乘法表

 

 

Formate函数的应用

 

 

16:00

 

 

生成器表达式 ：

 

生成器对象

生成器表达式是按需计算（惰性计算，惰性求值 ）用的时候返回一个生成器对象。而列表直接生成。用next函数拨到下一个。

而列表解析式  立即返回一个列表  

 

生成器：

（迭代器一定可迭代，）

迭代器从前到后走一遍不可回头，列表走完一遍后，可以重新迭代。

生成器表达式   生成一个生成器对象

Val  返回一个none 

Val  不能加  

 

生成器解析式和列表解析式的对比:

1. 生成器：延迟计算。 列表解析式：立即生成。
2. 生成器没有数据，内存占用极少，使用时一个一个返回。

而列表解析式构造新的列表要占用内存。

3. 生成器解释器将计算时间分散。

列表解析式耗时较多。

 

不可哈希  所以无法返回

生成一个列表，列表里面是int型

 

集合中有lst，lst不可哈希。

 

字典中key可hash就OK啦，value不限制

 

 

三种解析式： 集合解析式

             字典解析式   chr()  阿斯可码

生成字典中的3个元素

 

生成器对象是一个迭代器，所以一定是一个可迭代对象

迭代器 不一定是生成器对象

 

 

 

内建函数：

Id

  type不仅是一个内建函数，还是一个类。

Print的用法。。

Bool 型是int的一个子类

 

10000位的保留，剩下的迭代

Sum 正常 是累加和，20 再累加。

 

返回一个元素

 

字典不是sequence，不能reversed

Sorted 一定能排大小个

 

 

Next三次后，一直是100.

 

 

字典得遍历和可迭代对象的遍历

 

可迭代对象   迭代器  生成器 的概念非常重要

 

用itei可以将可迭代对象分装成迭代器

Zip  函数 也是惰性求值

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2018年4.10.2018

 

函数

功能划分，分装，复用

 

分类：内建函数

库函数

函数的结构：函数的定义（蓝色部分）和调用。

Def  define （定义）

结构：

def 函数名（参数）  【申明函数是谁和参数】

（缩进四个数） 代码块

Return 返回值

定义时的参数列表是形参。

调用的时候，用函数名加括号，调用时用的参数是实参。

Callable：可以调用的

 

形参和实参 是在区别函数定义和调用的时候说的

函数的参数（要掌握）：

传参的方式：

位置参数：  必须有顺序

关键字参数（keyword）：  顺序可以打乱   因为是x=… 的形式

形参有几个，必须传入几个参数

位置参数和关键字参数可以混用，但位置参数必须放在关键字参数前面

缺省值（4,5）

常见错误类型：

 

没有缺省值得必须放在有缺省值前面。（即简单的放在前面）

 

函数参数的默认值得作用：

Pot：端口

 

位置参数的可变参数：

*表示可以接受0个或多个，有多个实参时 收集为一个tuple. 零个时为空tuple.

关键字参数的可变参数：

**关键字参数的可变参数，可以接收多个关键字参数，收集的实参名称和值组成一个字典。

（*的参数）可变的参数都可以不给

可变参数，只在def() 中加*，一个*表示位置参数，两个*表示关键字参数。但在语句块中不加*。

 

定义参数和传参的整体逻辑： 简单的放在前面，不带*的放在前面。一定要记得输出打印，打印是可变参数不能加*。

可变参数在第一位的时候，x . y 已经是关键字参数，而不是位置参数。

X,  y是keyword参数。传入时要按关键字参数传入，且先满足x,y 再满足可变参数。

语法错误

 

只能传入两个参数，作用是将x,y 变成keyword-only参数

三个都必须给，且x y  必须是位置参数：x=…,y=。。。

keyword-only经常会伴随缺省值

 

 

 

 

上午总结：

4.10 pm:

参数的解构：

 

对字典参数的解构：

 

❤

 

4. 11号 上午

返回值和作用域：

Return的返回值:

函数的作用：复用和封装。

 

Return语句的本质和break类似。

函数如果执行了一个return语句，就会结束。想到函数的本质，y=f(x),给定一个x,只有唯一的y值。  没有reture，就默认返回none。

Assignment 赋值

 

 

 

闭包： 外部的作用域应用于内部

 

 

 

作用域很重要

全局：整个程序运行的环境

局部：

X+=1  赋值即定义

内层函数 用到外层函数（不是全局的）的自由变量     就是闭包

 

Nonlocal

 

Frames  幁

递归函数：函数直接或间接调用自己，就是递归。

Const  常量

栈一层一层压

 

 

递归函数：

 

练习：

阶乘：

将1234 逆序排列

3. 猴子吃桃：

 

匿名函数：

Lambda 函数

（lambda ： (表达式)   只能写一行

如何执行

 

生成器函数：

Yield 出现的函数  就是生成器对象

Yield 本意是让出的意思  不会立即执行

进程  线程

 

Yield from语法块

 

 

 

 

 

 

 

 

 

 

 

• 周二 函数本质总结,以及传参，以及作用域。

递归函数

复习：

函数的定义，作用域，封装，调用的概念。（每个语言都通用）

函数的作用：复用，封装

函数的定义，参数，返回值 ，定义域，函数递归。

函数的返回值只能有一个，python中函数都有返回值。

作用域：重要的概念。

内部函数用到外部函数的变量

Global 可以将内部的变量申明为全局变量。一般不用，破坏了函数的封装。  函数是用来复用和封装的。

LEGB

闭包：内层函数调用外层函数的变量

Nonelocal： 变量在上一层的局部作用域中定义。

 

默认值的作用域：

函数的标识符只是代指“一个对象”

全局的：

外层的变量内层可以看到。内层的外层看不到。

Build in  相当于全局的。   LEGB  原则

函数的销毁：本质还是用的引用计数。

 

 

递归函数定义：

自己直接或间接调用自己。

一定要有边界

调用函数：相当于摞盘子，调用了内部函数，必须先将这个函数调走，才能回到原来的函数。

递归函数：阶乘和斐波那契数列  递归函数

函数的本质：一个黑匣子，可以里面传参数。 函数内部如何设计。

生成器很重要

生成器的生成：  函数和表达式（函数里面有yield）

生成器（函数）调用时：返回的就是生成器对象（yield ）。

生成器一般放在for循环中。

生成器重要：

生成器的优势：惰性求值。

懒处理

预加载（本质：缓存）

树的概念（懂）：

结点

基本的数据结构：

一个前驱，后驱可以有

树的度：分叉的最大数

树的层次：分几层

路径，深度，

二叉树（重要）：一个树上分两个支

二叉树的性质，如何算它的节点。（2的对数）

满二叉树：

完全二叉树：

堆排序：用完全二叉树的性质

树的节点之间不允许交叉

二叉树的性质5：

 

 

 

 

 

 

 

 

 

 

高阶函数和科里化：

Y=g(f(x))

接受一个或多个函数作为参数

 

 

映射：

函数的本质：自由的对象

函数名就是标识符

高级函数：参数中传入函数，

 

Nonelocal

Sorted  函数的高阶函数

Filter（过滤器，数据清洗，过滤）

Map 映射（可迭代对象的每一个元素的形式转化）里面用lambda函数）

 

4.17下午（2点）：

Zip函数

Enumerate 函数

 

函数的currying：

将一个接受两个参数的函数转化成接收一个参数的函数。

将Z=F(x,y)的函数转化为：z=f(x)(y)

t的作用调用外层函数add()，调回内层函数的对象_add()。

闭包的定义：内层函数引用外层函数的变量。（上面例子中用到了闭包）

 

 

 

 

装饰器：

Print函数不属于业务代码，属于侵入代码。

 

函数调用必须在定义之后，但几个函数定义的时候没有先后顺序

@logger  后add1已经是_logger了，被包装函数add1。

Python中的装饰器重要

 

@logger 是装饰器语法

耦合度：dependency  一个程序中，模块和模块之间的依赖度。

只要定义一个新函数，就会开辟一个新的作用域。

 

装饰器的语法（非常重要）：@ logger

后面是被包装函数。（函数作用域，闭包，可变参数，嵌套函数，函数的调用，一切皆对象）

装饰器的本质是一个函数，将被包装函数业务增强，且是非侵入式的函数。

Python文档字符串（）相当于注释：

标识符是为了识别，与内存对象建立关系。

标识符和名称并不是一一对应的。

无参装饰器

带参装饰器（），如何克里化的

 

被包装函数名称被改变。所以用functiontools

装饰器的定义：

一个函数，用这个函数采用非侵入代码来增强另一个函数的功能，[被wrapped函数]作为装饰器的参数。

嵌套函数，克里化。

 

 

 

 

4.19号课程：

文档注释：

静态：变量先申明类型，编译期就可以发现变量类型是否匹配。

动态型：运行到某处时，才会抛异常。

解决动态语言的编译的弊端，用文档注释（不是强制性的）

Annotation

加入文档字符串。 （说明文档功能和变量类型）（可用help调用）

Annotation ：参数类型

返回值类型

#： 字符串中最外层用单引号：内层引用时

add.__annotation__返回一个字典（无序）

 

 

Parameters  参数们

Callable 可调用对象 ：  函数可调用。

 

可变参数：没必要加类型注解。（本身就是收集不同类型的参数）

参数标识符中没有*，*只是形式参数的。

 

 

 

Python中parameters . kind中其实没有（关键字参数）的类

 

@property  属性装饰器

Parameter 的kind