python由来

---

它的创造者:

Python的创始人为Guido van Rossum。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，作为ABC 语言的一种继承。之所以选中Python(大蟒蛇的意思)作为该编程语言的名字，是因为他是一个叫Monty Python的喜剧团体的爱好者。

我所理解的python

首先，它是一门计算机语言，用于人与计算机之间的交流。
           利用代码控制机器，从而达到与机器之间进行交流。
           机器不能够直接识别python语言，代码首先由人类写出来，然后通过解释器翻译给机器，然后机器开始执行命令，并通过解释器将结果传达给我们。

python历史
         1989年被Guido van Rossum创造出来
         到2008年python3.0诞生，与python2.0（老标准）完全不同，抛弃了旧有的东西
         2014年宣布2.7能够支持到2020年
         起初是搞运维开发的发现python适合作为运维脚本，在此之前使用的是shell（老男孩，靠python运维起家）
         大数据崛起
         R语言  选择python语言，全能语言
        2017年，也就是去年，AI元年，python崛起
        C++ Java不够简洁

python特点

速度比Java慢20倍
但是python应用在对速度不要求的领域
数据分析 人工智能（不差时间）
开发速度特别快
python成为大牛，有机会

python应用领域
全能，没有主打领域，样样通
优雅，设计哲学，简洁明了

环境anaconda+pycharm
python3.6

jupyter笔记本的使用

启动原理
  终端真正干活，属于解释器，求助于浏览器，通过浏览器将人类输入的东西输入并执行，然后将结果很清楚地展示给人类
下载并安装anaconda
选择使用jupyter笔记本
利用new新建一个笔记本（help中有快捷键）

好处：

做笔记的同时敲代码

python

是命令的集合体，执行的时候是一条一条执行，遇到问题就终止（这也是它为什么慢的原因）
逐行执行，读一条执行一条

alt+enter执行代码
打印出hello world
print("hello world")

syntaxerror 语法错误

注释
      机器不去执行注释内容
      注释一般用自然语言书写

注释的写法：

      行注释： 以井号开头，可以单独行，也可以在某行代码后边
      块注释： 好几行代码或者内容，以三个连续单引号或双引号开始和结束，                    
  中间任何内容机器都忽略

变量

重复使用的一个量或一个代号

变量命名规则

变量名可以包含数字，大小写字母，下划线或（更多，但是我们不推荐）
1，数字不可以开头,
2，以下划线开头有特殊含义
3，大小写不一样，俗称大小写敏感
推荐写法：
固定含义的英文单词和缩写，一般以posix命名规则为主
驼峰命名法
大驼峰，每个单词第一个字母大写，类的命名
MyGril
小驼峰
类似大驼峰第一个字母小写，普通变量或者函数名
myGril
posix写法
多个单词之间    用下划线链接，单词全部小写
my_gril

保留字和关键字

变量命名必须避开，不能跟关键字和保留字重复，系统自己实用的
class， def， break，for
查看关键字保留字
实际上关键字和保留字是不一样的
import keyword
print(keyword.kwlist)

变量声明
var_name=var_value
等号表示赋值
双等号表示相等
从右到左
var=var2=var3=value
var5,var6,var7=value1,value2,value3    //java中不能这样赋值
赋值实例
1.age=18
2.age=age1=age2=18
3.age4,age5,age6=4,5,6

 

变量类型

严格意义上python只有一种

标准数据一共有六种
1.数字类型Number
2.字符串类型str
3.列表list
4.元组tuple
5.字典dictionry
6.集合set

数字类型

数字类型没有大小限制
整数
分进制
二（机器唯一认识）0b开头，0b0001
，八0o开头
，十六0x开头，其实是四位二进制表示一个十六进制
以及十

浮点数
小数
计算机中表示小数可以有条件省略
3.1415
3.
0.5
.5
可以偷懒

科学计数法

定义跟数学定义
写法是用e/E后面跟整数表示10的指数
176.23 == 1.7634e2
0.876 == 8.76e-1

在python特殊的东西
复数
5+4j与数学中表示一致

布尔值
表示真或者假
True表示1     False表示0

字符串

用来表示一串文字
单引号
双引号
三引号（能够扩起多行信息）
作用基本一致
区别：单双引号可以交错使用，防止多引号时误认，因为每一个单/双引号都直接认识最接近它的那个引号

转义字符
用一个特殊的方法表示出一系列不方便写出的内容，比如回车键，换行键，退格键
借助反斜杠字符，一旦字符串中出现反斜杠，则反斜杠后面一个或几个字符表示已经不是原来的意思了，进行了转义
在字符串中，一旦出现反斜杠就要加倍小心，可能由转义字符出现
不同系统对换行操作有不同的表示
windows： \n
Linux: \r\n

字符串的格式化
把字符串按照一定的格式打印或者填充
格式化有两种方法
1.用%
2.format函数
%d表示应该放入一个整数
%s表示应该放入一个字符串
print（“{0}xxxxx”.format(参数)）

None
表示什么都没有
如果函数没有返回值，用于返回值
用来占位置
用来解除变量绑定

表达式
由一个数字或者几个或者变量和运算符组称的一行代码
通常会返回一个结果

运算符
分类：
算数运算符
关系（比较）运算符
赋值运算符
位运算
成员运算
身份运算
逻辑运算符

算数运算符

%取余运算
//取商运算
**表示次方
9**4代表9的四次方        
python没有自增自减运算

比较运算
比较的结果是布尔值

== < >>= <=   !=

赋值运算符
a+=7----a=a+7

逻辑运算符
对布尔值进行的运算
and   看做乘法 逻辑与
or  看做加法 逻辑或
  not  逻辑非

逻辑运算的短路问题

逻辑运算式，按照运算顺序计算，一旦能够确定整个式子未来的值，则不再进行计算，直接返回

成员运算符
用来检验一个变量是否属于另一个变量的成员
in
not in

身份运算 
用来检验两个变量是否为同一个变量
is
is not

运算符的优先级
括号具有最高的优先级    
优先级表格
  **  指数 (最高优先级)
  ~ + -   按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
  * / % //    乘，除，取模和取整除
  + - 加法减法
  >> <<   右移，左移运算符
  &   位 'AND'
  ^ | 位运算符
  <= < > >=   比较运算符
  <> == !=    等于运算符
  = %= /= //= -= += *= **=    赋值运算符
  is is not   身份运算符
  in not in   成员运算符
  not or and  逻辑运算符

程序结构
顺序
分支
循环

分支

if 条件表达式： （空格要有，冒号要有，用缩进表示一个块）
   语句1
   语句2
   语句3    
       ........
       条件表达式的结果必须是一个布尔值

双向分支
if 条件表达式：
    语句1
    语句2
    语句3
    .......
else:
    语句1
    语句2
    语句3
   .....
双向分支中一定会执行一个 if或者else
if 和else一个层级，其他的一个层级
语句块中的缩进必须一样indent（缩进）

       字符串类型要和数字比大小，要先转化为数字类型

多路分支
冷读术
if 条件表达式：
    语句1
    .......
elif 条件表达式：
    语句1
    ......
elif 条件表达式:
    语句1
    .........
    只会选择一个执行
    
  if语句可以嵌套使用

循环语句

for循环
for 变量 in 序列：
   语句1
   语句2
   .....
   列表就是一列数字或者其它值，一般用中括号表示
l={“张三”，“李四”，“老王”}
  for i in l:
     print(i)
     
range
生成一个数字序列，具体范围可以设定
for i in range(1,10):
       print(i)

for  else 语句
当for循环结束之后，会执行else语句
else语句是可选语句
for 变量 in 序列：
     语句1
     ...
else:
    语句
循环之break，continue，pass
break 无条件结束整个循环，循环猝死
continue无条件结束本次循环，从新进入下一轮循环
pass表示略过，一般用于占位
在数字1-10中，寻找数字7，一旦找到，打印出来，其余则什么都不做
for 循环中的变量表示，一般用i，k，m，n，或者indx，idx，item之类
在python中，如果循环变量名称不重要，可以用下划线（_)代替

while循环     
当某条件成立的时候就是循环，不知道具体的循环次数
while 条件表达式：
     语句块
只要条件表达式是真，就开始循环

函数
代码的一种组织形式
一个函数一般完成一种特殊的功能
函数需要先定义，然后调用
def(关键字） 函数名称（）：

定义一个函数

#只是定义的话不会执行
#1. def关键字，后跟一个空格
#2. 函数名，自己定义，起名需要遵循便令命名规则，约定俗成，大驼峰命名只给类用
 3. 后面括号和冒号不能省，括号内可以由参数
 4. 函数内所有代码缩进

函数的参数和返回值
形参：在函数定义的时候形参没有具体的数值，相当于一个占位符
实参：在调用函数的时候输入的值
返回值
函数执行的结果
使用return    关键字
如果没有return则默认返回None
函数一旦执行return，则无条件返回，就结束整个函数

help函数

在print中，end代表在print执行结束时需要进行的动作，print默认为是换行，这里可以做修改。(end=" ")

参数分类
  普通参数
      定义的时候直接定义变量名
调用的时候直接把变量或者值放入指定位置
            def 函数名（参数1， 参数2，....):
                函数体

            # 调用
            函数名（value1, value2,.......)

            # 调用的时候，具体值参考的是位置，按位置赋值
            
  默认参数
     形参带有默认值
调用的时候，如果没有对相应形参赋值，则使用默认值
      def  func_name(p1=v1, p2=v2..........):
          func_block

      #调用1
      func_name()

      # 调用2
      value1= 100
      value2=200
      func_name(value1,value2)
      
  关键字参数
语法
def func （p1=v1,p2=v2........）
    func_body
调用函数：
    func(p1=value1, p2=value2,.....）
  比较麻烦，但是很好用
  不容易混淆，普通参数按照位置的顺序进行传递，容易出错。使用关键字参数，不用考虑参数位置

  收集参数
参数在里面属于一个list格式。
收集参数之关键字收集参数——把关键字按字典格式存入收集参数中
语法：
  def func(**kwargs):
      func_body
   调用：
   func(p1=v1,p2=v2,p3=v3........)
   收集参数可以为空
   收集参数混合调用的顺序问题
   收集参数，关键字参数，普通参数可以混合使用
   普通参数和关键字参数优先
   普通参数-关键字参数-收集参数tuple-收集参数dict
  
收集参数的解包问题
把参数放入list或者字典中，直接把list值放入收集参数中
stu(*（list名称)）**用来解包

返回值
用return表示，若果没有，则默认返回None

函数文档
函数文档的作用是对当前函数提供使用相关的参考信息
文档的写法：
在函数内部开始的第一行，用三引号字符串定义符
一般具有特定格式
文档查看
使用help函数，help(函数名)
函数名__doc__

变量作用域

    变量由作用范围限制
   分类：按照作用域分类
   全局(global): 在函数外部定义
   局部（local)：在函数内部定义
   变量的作用范围：
   全局变量：在整个全局范围都有效
全局变量在局部可以使用（即函数内部可以方位函数外部定义的变量）
局部变量在局部范围可以使用
局部变量在全局范围无法使用
LEGB原则
L（Local）局部作用域
E（Enclosing function locale）外部嵌套函数作用域
G（Global module）函数定义所在模块作用域
B（Buildin）： python内置魔抗的作用域
**全局变量的数值不能够在局部改变

提升局部变量为全局变量
使用global

可以使用globals locals显示出局部变量和全局变量
结果会以字典形式呈现

eval函数
将一个字符串按照一个表达式来执行，然后将结果返回

exec函数
功能与eval差不多，，但是不返回结果

递归函数
特点：函数调用自己
优点：简洁，理解容易
缺点：对递归深度有限制，消耗资源大
python对递归深度有限制，超过限制报错   || java中也有
注意：在写递归程序的时候，一定注意结束条件

一个函数的函数返回值只能有一个，且后面不能够覆盖
应用：斐波那契额数列
def fib(n):
    if n == 1:
        return 1
        
    if n == 2:
        return 1 
    return fib(n-1) + fib(n-2)

内置数据结构
list
set
dict
tuple
一组有顺序的数据组成
l=[1,2,3,4]
l=list()
***其中list可以转变为tuple，tuple也可以转变为list,但是两者不能转为dict，dict转化为tuple和list是只能将K表示出来。

下标负数
左边的值一定小于右边
l=[1,2,3,4,5,7,8]
                   -2-1
     0,1,2
通过下标可以更改列表中该下标的值
利用del可以进行删除操作，进行删除操作后，并没有生成一个新的列表
删除一个变量后，此变量不能够再次使用
分片操作是生成一个新的list

分片操作会生成新的地址

内置函数id，负责显示一个变量或者数据的唯一确定编号
l=[1:4]表示将从1到3的数据显示出来
l=[:4]左边不写表示从0开始
右边不写代表到最后一个数终止
l=[1:4:2]表示隔一个抽取

ID操作
a=3
c=a此时两个变量ID相同，即都指向同一个数据
但是如果更改c的值
此刻a的值不会发生变化

解释：
那么看似牛X的Python变量是如何可以切换类型的呢，其实真正牛的不是Python变量，而是Python语言的解释执行器。

举个例子如下，解释器可以这么运作。首先在内存中地址为XXXX的地方存了一个变量1，然后运行到a=1时，发现整数1要赋值给变量a，所以解释器就知道了啊哈变量a是整型，然后a其实保存的是地址XXXX。
然后运行到a=0.1，解释执行器在内存中地址为YYYY的地方存了0.1，然后知道了啊哈a是浮点类型，然后a保存的地址变为了YYYY

    
内置数据结构
汉诺塔问题
规则：
每次移动一个盘子
任何时候大盘子在下面，小盘子在上面
方法：
n=1： 直接把A上的一个盘子移动到C上， A->C
n=2:
把小盘子从A放到B上， A->B
把大盘子从A放到C上， A->C
把小盘子从B放到C上， B->C
n=3:
把A上的两个盘子，通过C移动到B上去， 调用递归实现
把A上剩下的一个最大盘子移动到C上， A->C
把B上两个盘子，借助于A，挪到C上去， 调用递归
n = n：
把A上的n-1个盘子，借助于C，移动到B上去，调用递归
把A上的最大盘子，也是唯一一个，移动到C上，A->C
把B上n-1个盘子，借助于A，移动到C上， 调用递归

使用加号连接两个列表
使用乘号操作列表
列表直接跟一个整数相乘 
相当于把n个列表接在一起

成员资格运算，利用 b in l ，就是查看b是否在l内

not in   返回结果是一个布尔值

列表能被进行遍历

双层列表，也叫做列表嵌套
index表示list的下标
l=[["a",1,3],["b",2,4]]
访问
for k,v,w in l:
print(k,v,w)

创建一个列表
l=[1,6,8,9]
s=[i for i in l]

如果要使l中的数据都扩大十倍，那么可以这样：
s=[i*10 for i in l]

列表生成可以嵌套

列表生成中可以使用条件表达式格式
s=[m+n for n in l for m in s if m+n<100]

列表的常用函数

max min len list 

传值和传地址的区别
 对于简单的数值，采用传值操作，即在函数内对参数的操作不影响外面的变量
 对于复杂变量，采用传地址操作，此时函数内的参数和外部变量是同一份内容，
 任何地方对此内容的更改都影响另外的变量或参数的使用

append表示插入一个内容在末尾追加
l.append()
insert 指定位置插入
l.insert(位置下标，数值）
pop拿出最后一个元素
remove移除指定值的元素，是在原list上操作，不是新生成一个地址
clear清空列表
a.clear()
reverse翻转列表
a.reverse()
extend扩展列表，把一个直接拼接到另一个上
a.extend()
count查找指定值或元素的个数
a.count(数值)
copy是一个浅拷贝函数
b=[1,2,3]
c=b.copy()
其中b[1]和c[1]的地址相同，尽管b和c的地址不同
浅拷贝和深拷贝
作用，解决list类型简单赋值操作是传地址的问题

元组数值可以访问，但是不能够修改，可以是任意类型，除了不能修改，其它与list一样（索引，分片，相乘，序列相加，成员资格等）
访问不能够超标，但是切片可以

元组
index元素索引位置
index(数值)

集合set
一堆确定的无序的数据，集合中每一个数据成为一个元素
集合的定义
s=set()
print(type(s))
s={1,2,3,4}
集合没有索引，分片，数据具有唯一性可以用来排重
如果只用一个大括号，那么定义的是一个字典
集合内部只能存放可哈希数据
集合无序性
集合本身不可哈希

集合的内涵
初始化后自动过滤重复值    
集合中添加函数用add,因为本身没有顺序，不需要用append和insert
clear是原地清空
remove和discard区别
pop随机移除一个元素(但是据我观察好像是删除最小的）

集合的函数
intersection交集
different 差集
union并集
issubset检查一个集合是否为另一个集合的子集
issuperset超集

集合数学操作
直接减，差集

frozen     set冰冻集合，不能修改的集合
s=frozenset()

字典
一组组合数据，没有顺序，数据以键值对出现
创建
f={}
键值对
f={“a”:1,"b":,"c":3}
利用关键字参数
f=（a=1,b=2,c=3）
f=([("a",1),("b",2)])

成员检测的是Key

字典中比较特殊的函数
str()返回字典字符串格式

items函数返回字典的键值对元组格式，可迭代
key 返回键值组称的结构

get指定值返回，好处是可以设置默认值

fromkeys使用一个序列作为键，选择一个数据为所有键赋值