Python语言整理

Python简介：

python是一种解释型，面向对象，动态数据类型的高级程序设计语言，像Perl语言一样，Python源代码同样遵循GPL协议。Python优雅的语法和动态类型，在结合它的解释性，使其在大多数平台的许多领域成为编写脚本或开发应用程序的理想语言。

python的语法

python是一种弱类型语言，弱类型语言的有两个特点：1）变量不用声明就可以i直接赋值，对于一个不存在的变量赋值就相当于定义了一个新变量。2）变量的数据类型可以随时改变，比如，他弄一个变量可以一会被赋值为正数，一会被赋值为字符串。

执行语法

Python是可以直接在命令行中编写执行Python的语法。
我们直接打印一个hello word，显示的结果可以直接出来。

变量

变量可以看成一个小箱子，专门用来装程序中的数据，每个变量都拥有独一无二的名通过变量的名字就可以找到变量的数据。
常量也可以看做是一个装数据的小箱子，但是与变量不同的是：变量保存的数据可以被多次修改，但是常量一但被保存，某个数据之后就不能修改了

变量的赋值

变量就是通过“=”来进行赋值，即

n = 10 #将10赋值给变量n
real = True #将布尔值赋值给变量real
1
2

除了赋值单个数量。还可以将表达式的运算结果赋值给变量

sum = 10+20
rem
1
2

python的序列

python序列是指按照一定的顺序一次排列的一组数据，他们可以占用一块连续的内存。也可以分散 到多块内存中。
Python中的序列类型包括列表（List）、元组（tuple）、字典（dict）

列表

类似于数组，就是将一组数存储起来，方便后面的代码使用。但是在Python中是没有数组的，但是列表的功能比数组的功能更加强大。
1.创建列表

• 使用[ ]直接创建列表，格式如下：

listname = [ element1,emelent2,……,elementn]

这种创建方式的时候，列表中的元素可以有值，也可以为空，相当于一个空列表。

• 使用list()函数创建列表：
  list()是Python中的一个内置函数，他可以将其他数据类型转换成为列表类型。
  2.访问列表
  在访问列表的时候，可以使用两种方式来访问

listname[i]—使用索引的方式进行访问，i表示的是索引值。
listname[start : end : step]—使用切片的方式来访问，start表示开始的位置，end表示结束位置，step表示长度。

通过这个例子我们也可以发现，list所开始的第一位数字是0开始记位
3.删除列表
删除列表所用到的命令是：del

del listname

元组

元组是Python中一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排列的元素组成。
元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
  1.创建元组
• 使用（）直接创建，和list相似，使用“=”来进行赋值给变量。

tuplename = (element1, element2, …, elementn)

我没在列子中也可以看到，即便没有写小括号将元素包起来，他也是能识别的；所以小括号不是必须的，只要将各个元素隔离开就可以，但是为了格式的规范，还是建议写上的。

• 使用tuple()函数来创建元组，他和list()一样，可以将其他数据类型转为元组类型。
  
  2.查询元组（这里和list差不多，就直接上例子了）
  

字典

字典是一种无序的、可变的序列，他的元素是以键值对的形式存储，而列表和元组都是有序的序列，他们的元素在底层都是挨着存储的。
1.字典的特征

• 通过键而不是通过索引来读取元素
• 字典是任意数据类型的无序集合
• 字典是可变的，并且可以任意嵌套
• 字典中的键必须唯一
• 字典中的键必须不可变

2.创建字典

• 使用{ }创建字典

dictname = {‘key’:‘value1’, ‘key2’:‘value2’, …, ‘keyn’:valuen}

• 使用fromkeys()方式创建字典：

dictname = dict.fromkeys(list，value=None)—list表示字典中所有键的列表，value表示默认值，如果不写就是为空值

3.访问字典，命令格式为：

dictname[key]----方括号中的键是必须存在的，如果不存在会报错

Python流程控制

判断语句

Python条件和if语句
1.Python支持来自数学的常用逻辑条件：

• 等于：a==b
• 不等于：a!=b
• 小于：a<b
• 大于：a>b
• 小于等于：a<=b
• 大于等于：a>=b

2)if语句
if…else()语句：

a = 20
b = 10
if a>b
print("A")
else
print("B")
1
2
3
4
5
6

输出的结果为A。

循环语句

1.for循环
for循环用于迭代序列（前面说过的列表，元组，字典等）；Python的for循环关键字与其他语言不太一样，就直接看图吧

for循环中可以用到range()函数，即如果需要循环的一组代码指定次数；range()函数返回一个数字序列，默认情况下从0开始，并且默认的每次递增一个，并以指定的数字结束。
2.while循环

i = 1
while i < 7:
  print(i)
  i += 1
1
2
3
4

while语句中会使用break语句和continue语句。如果循环中有break语句，即便while条件为真，循环也会停止并且跳出循环；但是有continue语句的时候，表示可以停止当前的迭代，并且继续下一个迭代。

面向对象

面向对象编程是一种封装代码的方法；代码封装就是隐藏实现功能的具体代码，仅留给用户使用的接口。
Python中也支持面向对象的三大特征：封装、继承、多态。

面向对象的相关术语

• 类：可以理解是一个模板，通过它来创建出无数个具体的实例；类是抽象一类事物的总称，
• 对象：类时不可以直接使用的，需要通过类创建的实例才能使用，这个实例也就是对象。
• 属性：类中的所有变量称为属性
• 方法：类中的所有函数通常叫做方法

这里的重点就是类和对象。
类的命名规则首字母最好大写，可以采用驼峰写法，例如：StudentName
python中的类也是通过用class来定义，并且他也可以下成“class student(object)”的方式来定义，括号内的是class所继承的父类，如果不知道又想写的话写object就行。

class Demo:
    # 构造方法
    def __init__(self):
        print("hello Python")
    # 下面定义了一个类属性
    add = 'hello word'
    # 下面定义了一个say方法
    def say(self, content):
        print(content)
    #创建一个名为lei的Demo()类的对象。
    lei = Demo()
1
2
3
4
5
6
7
8
9
10
11

运行的结果就是

__ init __ ()是Python中的内置函数；当创建此类的新势力的视乎，这个方法可以叫做初始化方法。

构造函数

构造函数就是赋予参数属性，在类实例化的时候，会把属性附在实例化上面；构造函数可以显示掉用，但是这样的话会变成为普通函数，所以不要这样操作。
构造函数是以双下划线开头的类函数。创建对象的时候，在需要的情况下，构造函数可以接受参数。若火创建没有构造函数的类的时候，Python会自动创建一个不执行的任何操作的默认构造函数

类变量与实例变量：类变量总和类关联在一起的，实例变量总是和对象关联在一起的；所以我们在类实例化的时候传递进来不同对象的特征值，那么我们就需要保存不同对象的特征值，这个时候就需要用到self保存。
self：保存对象属性的，若果不保存的话对象是没有属性值得，并且self和对象有关和类没有关系。要注意的是，在想要通过实例化传递值得时候，是需要保存的，如果没有保存，就只能往上走了，去查找上面的值，所以在写构造函数的时候，一定要吧self写上。

类方法

__ new ()方法：是一种负责创建类实例的静态方法，他不需要使用staticmethod装饰器修饰，并且它优点于 init __ ()初始化方法被调用。
__ repr __()方法：显示属性
__ del __()方法：销毁对象
__ dir __()用法：列出地所有属性名
__ dict __()属性：查看对象内部所有属性名和属性值组成的字典

公开和私有

protected：保护，可以被子类进行调用
private：私有方法，只可以被自己调用，子类也不行。
public：公有的
Python中通过两个下划线认为是私有属性，可以使用__dict __()看见。如果想要修改私有属性，就需要使用个modify_price来进行修改。

from c9_1 import Array6
arr6 = Array6([1,2,3], 3)
print(arr6.__dict__)
print(Array6.__dict__)
1
2
3
4

输出结果是：

输出结果里面确实有__price属性，只是在编译的时候编辑器给它加上了一个横杠和类名。

这里就产生了一个疑问，明明定义的是私有变量，为什们外部依旧可以访问？
这是因为你访问的就不是私有变量，他只是新创建了一个变量，并且访问的是新生成的这个变量。

python的c3算法
python的c3算法就是多重继承。
mro（方法解释顺序），就是判断在多继承的时候来自哪个类。在判断mro之前需要先确定线性序列，然后在查找路径是由序列中哪个类的顺序决定，所以c3算法是先生成一个线性序列在尽行判断

闭包

Python的闭包：定义函数与外部环境变量为闭包，也就是说闭包=函数+环境变量（函数在定义的时候）；闭包并不是必不可少的，他只是编程的一种，属于函数式的编程。
闭包是由函数和自由变量的引用组成。举个例子：

def demo1()
	a=3
	def demo2(x)
		return a*x*x
	return demo2
a=10
d=demo1()
print(d.__closure__)
print(d(2))
1
2
3
4
5
6
7
8
9

这个的运行过程就是d=demo1()的结果就相当于d=demo2，也就是等于demo2的函数名；所以子执行的时候需要在家个()也就是print(d(2))这样。
但是需要注意的是，return返回的函数不要引用任何循环变量，否则会报错。
如果闭包的时候要改变外部的局部环境时候，加上一句nobocal就会认为是非环境变量了。

列表生成式

可以理解为用一种优雅的语言来写for循环。

aa=[i*i for i in range(1,5)]
print (aa)
1
2

结果是：

列表常用的方法

1. append()方法：用于在列表末尾添加型的对象—语法：list.appandd()
2. count()方法：用于统计某个元素在列表中出现的次数—语法：list.count()
3. extend()方法：用于在列表末尾异性追加另一个序列中的多个值—语法:list.extend(seq)
4. index()方法：用于从列表中找出某个值第一个匹配项的索引位置—语法：list.index(x[, start[, end]])-----x:查找的对象；start：开始位置，end：结束位置
5. pop()方法：用于移除列表中的一个元素，默认为列表中的最后一个元素，并且返回该元素的值—语法：list.pop([index=-1])
6. remove()方法：用于移除李彪中某个值的第一个匹配项----语法：list.remove(obj)
7. reverse()方法：将元素倒序排列

生成器

生成器（generator），也就是将列表的[ ]变成( )，就创建了一个generator。生成器保存的是算法，每一次调用next(g)，就可以计算出g的下一个元素的值，直到计算到最后一个元素的时候，会抛出StopInteration的错误，所以为了优化，我们可以用for循环来进行调用，for循环可以将异常捕获，解决StopInteration错误的问题。

ll =(x*x for x in range(10))
print(next(ll))
1
2

结果是：

与列表生成式的区别：
用的话推荐用生成器，因为他是惰性匹配，如果有很多数据的时候，列表生成式会将所有的数据都存储进来，而生成器采用的是惰性匹配，他会循环一次算一次，极大的节省了空间

yield命令：可以将正常数列变成生成器，他可以从中断的位置继续运行。

generator函数和普通函数的执行流程不同，普通函数遇到return语句或者最后一行函数语句就直接返回，但是generator函数再用next()调用执行的时候，遇到yield语句也会返回，但是再次执行的时候会从上此次返回的yield语句处执行。

迭代器

迭代器：iterator；可以被next调用并不断返回下一个值的对象称为迭代器；生成器就是一种迭代器，
可迭代对象（iterable）：可以被for循环的数据，都被叫做可迭代对象----字符串、元组、列表、字典、set（在定义中最好放一个数组；set最主要的功能是可以去重）
优先级genarator>iter>iterable
利用iter()函数可以将可迭代对象变成迭代器。同时想要将变量变成迭代器需要用到iter和next的魔术方法。
字典在Python中可以将key和value直接打印出来
1.在使用字典循环的时候，如果直接使用print(i)的话他是循环出来的是key值，如果想要循环vlaue的的haul可以使用数组进行循环。

2.但是字典在Python中有现成的包可以直接将key和value循环出来。可以使用items()方法来。

Python的高阶函数1）匿名函数

使用lambda关键字修饰的简单函数

lambda x,y: x>y?x:y
2）map(__func, __iter1)：使用__iter1迭代器执行__func函数—第一个参数传的是函数名，第二个参数传的是参数值。

3）reduce(__func, __iter1)：使用__iter1迭代器执行__func函数，将上一次计算的结果作为下一次计算的参数

4）filter(__function,__iterable)：用__function函数过滤，__iterable中的元素—过滤函数，满足的才会过滤，不满足的话会直接忽略；也就是说，filter必须能判断出返回的真假。

5）sorted(__iterable,key,reverse)：依据key的值排序__iterable中的元素，reverse决定是否逆序—可以加绝对值

filter和map的相似于不同：
相似：filter和map一样也是接收一个函数和一个序列
不同：filter把传入的函数一次作用在每个元素，然后根据返回的值是True还是False决定是留还是丢掉。

查看的教程：
http://c.biancheng.net/python/base/
https://www.runoob.com/python/python-tutorial.html
https://www.yiibai.com/python/python-constructors.html