牛客网刷题之路---Python纠错本(持续更新)

一、关于变量

• 变量无需事先声明
• 变量无需指定类型
• 程序员不用关心内存管理
• 变量名会被“回收”
• del语句能够直接释放资源
• 变量只有被创建和赋值后才能被使用

二、关于数据类型

1、list

1. 构造list，使用[ ]把list的所有元素都括起来就是一个列表，用变量L表示。其中的元素不要求是同一种数据类型。
2. 列表中元素是有序的。可以通过索引来访问。
3. 访问list的元素，L[0]：表示列表中的第一个元素，L[-1]：表示列表中的最后一个元素。 L[起始索引:终止索引]：表示访问列表中的多个元素，包含头，不包含尾。
4. 列表是可以被修改的，包括添加元素，删除元素，替换元素。
     1）添加元素：L.append(元素)、L.insert(元素插入到列表中的位置，元素)
     2）删除元素：L.pop()<==>L.pop(-1)，L.pop(要删除元素在列表中的位置)、L.remove(要删除元素)，删除列表中第一次匹配到的元素
     3）替换元素：L[要替换元素在列表中的位置]=新的元素值
5. 计算列表的长度：len(L)
6. 计算列表中某一个元素在列表中出现的次数：L.count(要统计的元素)
7. 列表拼接，用+，L1=[1,2],L2=[3,4],L1+L2=[1,2,3,4]
8. 列表中元素复制，用*，L= [2,3],L*3 = [2,3,2,3,2,3]

2、tuple

1. 构造tuple，使用（）把tuple的所有元素都括起来就是一个元组，用变量T表示。python规定只有单个元素的元组应表示成（元素，），避免歧义。其中的元素不要求是同一种数据类型。
2. 元组中元素是有序的。可以通过索引访问。
3. 访问tuple的元素，T[0]：表示元组中的第一个元素，T[-1]：表示元组中的最后一个元素。
4. 元组是不可以被修改的，因此它没有append（）、insert（）、pop（）等方法。
   注意: 元组中可以包含列表，如T= （1，2，[4，5]），T[2] = [ ],错误;T[2][1] =5,正确

3、dict

1. 构造dict，使用{ }把dict所有元素都括起来就是一个字典，用D表示。D中元素的形式是key：value的形式。其中的key或者value都不要求是同一种数据类型。
2. 字典中元素是无序的。不可以通过索引访问。
3. 访问dict的元素，使用D[key]来查找对应的value。如果key不存在，则会报错。为避免报错：
    1）访问前先判断
     if key in D：
     print（D[key]）
    2）使用get()方法
     print(D.get[key])，key不存在会输出None
4. 字典是可以被修改的。D[key] = 新的value，如果key不存在，则会想字典中添加这一键值对。
   注意：
   字典的一个最明显的特点是查找速度快，无论字典中有多少个数据，查找的速度都是一样的，因为它是按照key来查找的。但是它占用的内存大。典型的以空间换时间的思想。

4、set

1. 构建set，S = set(传入一个列表)，或者S = {元素1，元素2，…}。其中的元素不会重复。如：S= set（[1,2,3,3,4,5]）,print(S) #{1,2,3,4,5}
   注意：创建空集合只能使用S = set()，而不能使用S = { }，这是用来创建空字典的。
2. 集合中元素是无序的。不可以通过索引来访问元素。
3. 集合是可以被修改的。
4. 添加元素和删除元素
     1）S.add(元素)
     2）S.remove(元素)。删除之前要进行判断：if 元素 in S,S.remove(元素)，否则会报错。

三、大小比较

• Python2 与 Python3 均不支持复数比较大小
• Python2 与 Python3 均支持连续比较，相当于 3>2 and 2>2，后一个判断式为假，因此整个表达式都为假。
• Python2 支持数字与字符串之间的比较，而 Python3 则不支持，会报以下错误：TypeError: ‘>’ not supported between instances of ‘int’ and ‘str’
• tuple 的比较是从两者的第一个元素的 ASCII 码开始，直至两个元素不相等为止，若前面元素都相等，则元素个数多的 tuple 较大。

(1,9) < (2,3) # True
(8,9) < (1,2,3) # False
(1,2,3) == (1,2,3) # True
(3,2) < (‘a’,‘b’) # True
字母与数字的ASCII 码大小范围是 “a-z” > “A-Z” > “0-9”，D选项中 ‘a’ < ‘x’，因此
‘abc’ > ‘xyz’ # False

• 类似元组、字符串、列表这类格式，在进行两者之间的比较时，先从第一个元素开始比较 ASCII 码值大小，如果相等，则依次向后比较，如果全部相等，则比较数量大小。

ASCII 码值大小：

数字：0-9: 48-57
字母：A-Z：65-90，a-z： 97-122

一串数字、字符的 ASCII 码值大小取决于最后一位的 ASCII 码值，
例如：
  123454 的ASCII 码值为 52

  4 的 ASCII码值 也为 52

  ABCDA 为 65

  A 也是 65

四、编译型语言和解释型语言

解释性语言和编译性语言的定义：
计算机不能直接理解高级语言，只能直接理解机器语言，所以必须要把高级语言翻译成机器语言，计算机才能执行高级语言编写的程序。翻译的方式有两种，一个是编译，一个是解释。两种方式只是翻译的时间不同。

解释性语言（python，java）的定义：
解释性语言的程序不需要编译，在运行程序的时候才翻译，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就需要逐行翻译一次，效率比较低。
现代解释性语言通常把源程序编译成中间代码，然后用解释器把中间代码一条条翻译成目标机器代码，一条条执行。

编译性语言（C、C++）的定义：
编译性语言写的程序在被执行之前，需要一个专门的编译过程，把程序编译成为机器语言的文件，比如exe文件，以后要运行的话就不用重新翻译了，直接使用编译的结果就行了（exe文件），因为翻译只做了一次，运行时不需要翻译，所以编译型语言的程序执行效率高。

解释型语言的特点：

• 非独立：需要依赖解释器
• 效率低：边解释边执行。解释器每次运行程序时都要先转成另一种语言再作运行，因此解释器的程序运行速度比较缓慢。它不会一次把整个程序翻译出来，而是每翻译一行程序叙述就立刻运行，然后再翻译下一行，再运行，如此不停地进行下去。（而编译型语言被编译器一次性将所有源代码翻译成另一种机器语言，运行时无需再依赖编译器，因此运行速度比较快。）
• 跨平台兼容性好（编译型语言进行移植后要重新编译）

五、闭包

1、如果一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数
2、在一个外函数中定义一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
3、一般情况下，如果一个函数结束，函数内部的所有东西都会释放掉，还给内存，局部变量也会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给内部函数，然后自己再结束。

 def adder(x):
    def wrapper(y):
    
        return x + y
    
    return wrapper
adder5 = adder(5)
print(adder5(adder5(6)))
print(adder5(6))
print(adder5(1))
print(adder5(2))
---------------------------------
16
11
6
7 

六、Python的数据类型

Python中有6个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（集合）

其中数字类型有：
Python支持的数字类型有4种：

• int（有符号整型）
• long（长整型）
• float（浮点型）
• complex（复数）

注意：
string不是char！！！
可变数据类型：列表list[ ]，集合set，字典dict{ }
不可变数据类型：字符串str，整型int，元组tuple( )

七、map函数

map( )接收两个参数，第一个参数function，另一个参数是list，function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表。

map( )函数语法：

map(function, iterable, ...)

八、赋值、浅拷贝和深拷贝的区别

赋值： b = a，a和b都指向同一个对象，指向同一块内存空间（id），任意一方数据的改变，另一方数据也跟着一起改变

首先深拷贝和浅拷贝都是对象的拷贝，都会生成一个看起来相同的对象，他们的本质区别是拷贝出来的对象的地址是否和原对象一样，也就是地址的复制还是值的复制的区别。

可变对象和不可变对象：

可变对象指的是，一个对象在不改变其所指向的地址的前提下，可以修改其所指向的地址中的值；

不可变对象指的是，一个对象所指向的地址上的值是不能够修改的，如果你修改了这个对象的值，那么它指向的地址就改变了，相当于你把这个对象所指向的值复制了一份出来，然后做了修改后保存到另一个地址上了，可变对象不同的是，直接在对象所指的地址上把值修改了，而这个对象的地址并没有发生变化。

深拷贝和浅拷贝需要注意的地方就是可变元素的拷贝：

在浅拷贝时，拷贝出来的新对象的地址和原对象的地址是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象中可变元素的地址是相同的，也就是说浅拷贝拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新的地址里面去，而是和原对象里的可变元素指向了同一个地址，所以在新对象或原对象中对可变元素做修改时，两个对象同时改变；

而深拷贝是将浅层次和深层次的数据结构一起拷贝到新的地址里面，两者指向完全不同的地址（包括可变元素也指向不同的地址），所以在新对象或者原对象对可变元素修改时，不会影响另一方的可变对象的值。