python summary(for previous 6 weeks)

Meghan(haven’t been fullly organized)

 

3.19和3.20  上课总结:

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

 

输入设备               内存器                    输出设备

 

CPU(处理器 ,运算器, 寄存器 和多级缓存)

 

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

 

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

动态:不提前规定类型,直接赋值。

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

 

  1. 编程: 算法 +数据结构

算法:是数据如何计算

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

  1. Python 的解释器

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

Ipython 是一种交互式的解释器

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

Pypy 应用动态编译技术.

  1. Python的基础语法

数字的类型:整数int

进制binary  二进制

Oct     八进制

Hex     16进制

浮点数 float

复数  complex

布尔值  bool(true  false)

  1. 字符串

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

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

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

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

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

用转义符和其符号:

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

\’ 单引号       \”双引号

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

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

  1. 标识符(一般用字母开头,注意 大小写敏感型
  2. 再次强调 python是一门强类型、动态的解释型语言。
  3. 运算符:

 

算术运算:

+  –

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的平方)

(箭头的尖  就是位移动的方向)

  1. 原码(写成二进制格式:9 ==> 0b1001),反码,补码2

正数

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

负数

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

      反码:符号位不变,其余按位取反。

                            例:-1反码:1111 1110

      补码:符号位不变,其余按位取反后加1

                            例:-1的补码 1111 1111

 

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

 

  1. 运算符:

算术运算符和位运算符。

 

比较运算符:

==   是否等于

!=   是否不等于

<     小于                      >   大于

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

 

逻辑运算符:

与 and

或  or

非  not

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

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

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

 

赋值运算:

+=   -=  /=  *=   %=

A= min (1,4)   max

成员运算:in ,   not in

 

 

身份运算:is ,   not is

总结7种运算符

  1. 算术运算符

+ ,-, * ,/ ,//,%, ** 。

  1. 位运算

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

  1. 比较运算

==,!=,>,<, >=,<=

  1. 逻辑运算

and   or  not

注意and 和or的短路运算

  1. 赋值运算

+=,-=,、/=,*=,%=、

a = min(1,7)  max

  1. 位置运算

In  ,not in

  1. 身份运算

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

  1. 列表的初始化

Lst=[ ]

Lst=list()

Lst=[1,2,3]

Lst=list(range(10))

  1. list de 初始化过程:

lst=[ ]

lst=list()  new empty list

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

new list initialized from iterables’ items

  1. 列表的索引访问

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

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

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

通过index函数,括号中是list的元素,最后输出元素对应的index值(偏移量)

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

 

  1. 列表的查询‘

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

返回的是在(开始index,结束index)中元素第一次出现对应的index值。

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

  1. 列表元素的修改:

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

 

  1. 列表增加,插入元素

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 放在前面,所有的转义符号将不起作用

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

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

  1. 字符串通过“+”连接。
  2. 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. 一个个 字符 (不是字节)组成的有序的序列,单引号,双引号。

可迭代和可索引定义不同

  1. 字符串是不可变对象

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

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字符串的加减 乘

  1. 字符串的分割

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: 可变有序的字节序列

  1. 对字符串进行编码:

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

  1. 下面是对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. 阶乘

 

 

  1. 转置矩阵

 

 

 

 

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. 生成器没有数据,内存占用极少,使用时一个一个返回。

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

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

列表解析式耗时较多。

 

不可哈希  所以无法返回

生成一个列表,列表里面是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:

参数的解构:

 

对字典参数的解构:

 

 

  1. 11号 上午

返回值和作用域:

Return的返回值:

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

 

Return语句的本质和break类似。

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

Assignment 赋值

 

 

 

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

 

 

 

作用域很重要

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

局部:

X+=1  赋值即定义

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

 

Nonlocal

 

Frames  幁

递归函数:函数直接或间接调用自己,就是递归。

Const  常量

栈一层一层压

 

 

递归函数:

 

练习:

阶乘:

将1234 逆序排列

  1. 猴子吃桃:

 

匿名函数:

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

本文来自投稿,不代表Linux运维部落立场,如若转载,请注明出处:http://www.178linux.com/96524

联系我们

400-080-6560

在线咨询

工作时间:周一至周五,9:30-18:30,节假日同时也值班

QR code