Python

条件语句

if 条件:
	代码
else:

循环语句

while语句

while 条件 :
    #代码

for语句

for ... in ... :
    #代码

举例

#将2到x-1 之间的数相加得到cnt
for k in range(2,x):
    cnt += k

异常处理

#举例
x = int(input())
t = [1, 2, 3, 4, 5]
try:
    print(t[x])
    print('hello')
except:                             #如果有异常（比如本例中x不在范围内时)
    print('x is not a valid index')
else:                               #做过except后就不会再做else
    print('nothing')
finally:                            #不管有没有异常都会做
    print('anyway')

#语法格式
try:
    语句块1
except 异常类型1:
    语句块2
except 异常类型2:
    语句块3
...
except 异常类型N:
    语句块N+1
except:
    语句块N+2
else:
    语句块N+3
finally:
    语句块N+4

集合

• 集合是无序的，里面没有重复的元素。无序指的是程序员无法控制他的位置顺序，集合会自动把数据排好顺序emm
• 集合中元素无法通过下标访问
• 集合用{}，列表用[]，元组用()，字典也用{}

add() 和 remove()

• 添加和删除集合元素

min()、max()、len()和sum()

• 最小、最大、长度、求和

set()

• 将其他的转化为集合
• 得到一个空的集合（如果直接用一个 {} 则会得到字典而不是集合）

集合操作

• s1 = {1, 2, 3, 4, 5}
• s2 = {9, 2, 4, 6}
• 合集：s1 | s2 = {1, 2, 3, 4, 5, 6, 9}
• 交集：s1 & s2 = {2, 4}
• 对称差：s1 ^ s2 = {1, 3, 5, 6, 9}
• 差集：s1 - s2 = {1, 3, 5}

字典

字典是用键来存取数据的，数字、字符串和元组都可以作为键。键所对应的值可以是任何类型，数字、字符串甚至列表和字典都可以作为值存放在字典中。

简单举例

d = {'one': 1, 'two': 2}
#d['one'] = 1


#增加条目
d['three'] = 3
#此时 d = {'one': 1, 'two': 2, 'three': 3}


#删除条目
del d['two']
#此时 d = {'one': 1, 'three': 3}


#修改条目
d['one']=11
#此时 d = {'one': 11, 'three': 3}


#遍历条目：
for name in d:
	print(d[name])
#结果：
1
3

for name in d:
	print(name)
#结果：
one
three

相关函数

d = {'one': 11, 'three': 3, 'ki': 340}

• len()
  获得字典中条目数量

  len(d) = 3
  

• min()
  获得最小的key

  min(d) = 'ki'
  

• max()
  获得最大的key

  max(d) = 'three'
  

• sum()
  sum函数的能否使用取决于key的类型
• get

  d.get('one') = 11
  d.get('ok') # 不报错，无反应/无输出
  d.get('ok',0) = 0
  

函数的定义与调用

函数的定义与调用

内置函数无需定义，直接调用

函数要先定义再使用

自定义函数语法格式

• 方法一

  def 函数名（参数表）
      函数体
  

  # 举例 定义函数 y = x**2 + 1
  def f(x) :
      value = x**2 + 1
      return value
  

  #求斐波那契数列前n项
  def fibs(n):
      result = [1, 1]
      for i in range(n - 2):
          result.append(result[-2] + result[-1])
      return result
  
  print(fibs(5))
  

• 方法二

  用lambda表达式，lambda定义了一个匿名函数，lambda可以编写简单的函数，而def是用来处理更强大任务的函数

  #格式
  lambda 一个或多个参数:表达式
  
  #举例
  g = lambda x,y,z:x+y+z
  #把lambda定义的匿名函数赋给函数g
  print(g(1,4,5))
  #结果为 10
  

函数参数

• 形参：定义函数时的参数
• 实参：调用函数时传入的参数
• 其他
  • 位置参数：传入参数按照顺序依次赋值给形参
  • 关键字参数：可以不按照顺序传参

    def f(x1,y1,x2,y2):
        ...
        return ...
    print(f(x1=1,y2=5,y1=3,x2=4)) #不按照顺序传参
    

  • 默认值参数：当调用方没有提供对应形式参数的值时，你可以指定默认形式参数值。如果你提供实参，在调用时会代替默认值。默认参数值在函数对象被创建时计算。

    def f(x1,y1,x2,y2=5):   #y2默认为 5
        ...
        return ...
    print(f(1,3,4))
    

  • 数量可变参数：当函数参数数目不确定时，星号将一组可变数量的位置参数集合成参数值的元组

    def countnum(a,*b): # *收集参数到元组中，**收集参数到字典中
        print(b)
        print(len(b)+1)
    countnum(3,7,9)
    countnum(5,8,1,6,89)
    
    #运行结果
    (7,9)   #以元组的形式存放
    3
    (8,1,6,89)
    5
    
    # *收集参数到元组中，**收集参数到字典中
    

    • 实参拆包
      *或**加在形参前面，表示不定长参数，分别用来接收不带变量名的多余参数和带有变量名的多余参数，分别将他们以元组和字典的形式收进函数。
      *加在实参前面，意味着拆包。*表示将序列拆成一个个单独的实参。

    >>> l = [2,7,5]
    >>> print(l)
    [2,7,5]
    >>> print(*l)
    2 7 5
    

• 可变对象和不可变对象当参数
  • 当实参是不可变对象时，形参值改变不会影响实参。
  • 当实参是可变对象时，形参值改变可能会影响实参。

函数的返回值

• 格式：return 表达式（表达式的值即为返回值）
• 若函数没有用return语句返回，或return后面没有表达式，这时函数返回的值为None。
• None是Python中一个特殊的值，虽然他不表示任何数据，但仍然具有重要的作用。
• 返回的不仅可以是值还可以是函数。

命名空间和作用域

1. 变量可被访问范围称为变量的作用域，也称为变量命名空间或变量名字空间。Python程序用命名空间区分不同空间的相同名字。
2. Python解释器启动时建立一个全局命名空间。在全局命名空间中定义的变量时全局变量。
3. 每一个函数定义自己的命名空间，函数内部定义的变量是局部变量。
4. global关键字
   global关键字可在函数中声明全局变量

   def ...:
       global var 1
       ...
   #此时的var在全局中值也为1
   

递归算法

• 函数调用自身的编程技巧称为递归。
• 编写递归函数时，必须告诉他何时停止递归，从而避免形成无限循环。
• 举例：斐波那契数列

  def fib(n):
      if n == 0 or n == 1:
          return 1
      else:
          return fib(n-1) + fib(n-2)
  
  #改进斐波那契数列递归程序
  pre = {0:1,1:1}
  def fib(n):
      if n in pre:  #可以用in检查字典中是否有n这个关键字
          return pre[n]
      else:
          newvalue = fib(n-1) + fib(n-2)
          pre[n] = newvalue #增加字典的条目
          return newvalue
  

内置函数

• sorted函数
  1. 对字符串，列表，元组，字典等对象进行排序操作。
  2. sort是应用在list上的方法，sorted可以对更多数据类型进行排序操作。
  3. 即便都是对列表操作，list的sort方法返回的是对已经存在的列表进行操作，而内置函数sorted返回的是一个新的list，而不是在原来基础上进行的操作。
  4. 函数语法：

     sorted(iterable, /, *, key=None, reverse=False)
     sorted(iterable,[key,[reverse]])
     iterable -- 序列，如字符串，列表，元组等
     key -- 函数，缺省为空
     reverse -- 排序规则
     reverse = True 降序，reverse = False 升序（默认）
     

• map函数
  1. map会根据提供的函数对指定序列做映射。
  2. 函数语法

     map(func, *iterables)
     第一个参数func是对参数序列中的每一个元素调用func函数，iterable是序列
     

  3. 举例：

     >>> print(list(map(lambda x:x**2,[1,2,3,4,5])))
     [1, 4, 9, 16, 25]
     

• zip函数
  1. 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或迭代器。
  2. 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
  3. 函数语法

     zip([iterable,...])
     iterable,... 两个或多个序列
     返回值：返回元组列表
     

  4. 举例：

     >>> a = [1,2,3]
     >>> b = [4,5,6]
     >>> c = [4,5,6,7,8]
     
     >>> print(list(zip(a,b)))
     [(1, 4), (2, 5), (3, 6)]
     
     >>> print(list(zip(a,c)))  # 元素个数与最短的列表一致
     [(1, 4), (2, 5), (3, 6)]
     

• eval和exec函数
  1. eval是计算表达式，返回表达式的值。
  2. exec可运行Python的程序，返回程序运行结果。
  3. 举例：

     >>> x,y=3,7
     >>> eval('x+3*y-4')
     20
     >>> exec('print("hello world")')
     hello world
     

• all和any函数
  1. all()和any()函数将可迭代的对象作为参数。
  2. all函数参数都是True时，才返回True，否则返回False。
  3. any函数参数只要有一个为True，就返回True，参数全部是False时，返回False。

程序结构

• 包
  1. 多个模块文件组织成的目录称为 包 。
  2. 包是一个目录，其中包含一组模块文件和一个init.py文件。
  3. 如果模块存在于包中，使用“import 包名.模块名”形式导入包中模块。
  4. 用以下形式调用函数：“包名.模块名.函数”
• sys模块
  1. sys.path 模块搜索路径的字符串列表
  2. sys.argv 从程序外部向程序传递参数
  3. sys.stdin 标准输入
  4. sys.stdout 标准输出
  5. sys.stderr 标准错误输出
  6. sys.getdefaultencoding() 获取系统当前编码

文件

文件读写

文件读写操作

• 文件读写步骤
  1. 打开文件
  2. 处理数据
  3. 关闭文件
• open函数
  1. fileobj = open(filename,mode)
  2. fileobj是open()返回的文件对象
  3. filename是该文件的文件名
  4. mode是指明文件类型和操作的字符串
  5. mode的第一个字母表明对其的操作。
  6. mode的第二个字母是文件类型：t（可省略）代表文本类型文件；b代表二进制类型文件。
• 文件打开模式
  1. r 只读模式（默认）
  2. w 覆盖写模式（不存在则新创建，存在则重写新内容）
  3. a 追加模式（不存在则新创建；存在则只追加内容）
  4. x 创建写模式（不存在则新创建，存在则出错）
  5. + 与 r/w/a/x 一起使用，增加读写功能
  6. t 文本类型
  7. b 二进制类型
• 文件读写函数
  1. open() 打开文件
  2. read(size) 从文件读取长度为size的字符串，如未给定或为负则读取所有内容
  3. readline() 读取整行，返回字符串
  4. readlines() 读取所有行并返回列表
  5. write(s) 把字符串s的内容写入文件
  6. writelines(s) 向文件写入一个元素为字符串的列表，如果需要换行则要自己加入每行的换行符
  7. seek(off,whence=0) 设置文件当前位置
  8. tell() 返回文件读写的当前位置
  9. close() 关闭文件。关闭后文件不能再进行读写操作

多行文件读写

• 用readlines()读写多行文件
• 基本框架

  f = open("score.txt","r")
  for line in f.readlines():
    print(line) #处理行
  f.close
  

• 可用嵌套列表存放多行内容

输入输出重定向

• sys.stdin 标准输入
• sys.stdout 标准输出
• sys.stderr 标准错误输出

  import sys
  #从文件读入变为从键盘输入，改变输入源
  s = sys.stdin.readlines()
  print(s)
  

用Pandas模块读写常见格式文件

• Pandas模块是第三方模块函数，需要先安装，再用import引入模块，才能调用模块中的函数。
• Pandas模块是Python的一个数据分析包
• 最初被作为金融数据分析工具而开发出来，为时间序列分析提供了很好的支持
• 是基于NumPy的一种工具
• 纳入了大量函数和一些标准的数据模型
• DataFrame数据类型
  1. 是Pandas库的一种数据类型
  2. 是一个行和列都具有标签的表格，与excel表格并无不同
  3. 可由元组、列表、字典或另一个DataFrame构造出来
• 用Pandas读写各种类型文件
  1. read_csv      to_csv   读写csv文件
  2. read_excel    to_excel   读写excel文件
  3. read_json   to_json   读写json文件

数据可视化——ploty模块 (4.0版本及以上)

• 是一个基于JavaScript的动态绘图模块。
• 其默认的绘图结果是一个HTML网页文件，通过浏览器就可以查看
• 有强大又丰富的绘图库，支持各种类型的绘图方案
• 其绘图结果可与web应用无限集成

类和对象

类和对象的概念

• 面向对象程序设计（OOP）
  • 使用对象进行程序设计，实现代码复用和设计复用，使得软件开发更高效方便。
• 类
  • 是一种对象的模板和数据类型。
  • 它定义了对象的属性（数据），并提供用于初始化对象的初始化程序和操作这些属性的方法。
• 对象
  • 对象是类的一个实例。
  • 使用构造方法来创建一个对象。
  • 使用圆点运算符（.）通过引用方法和变量来访问对象的成员。
  • 术语对象（object）和实列（instance）经常是可以互换的。
• 举例

  s = str('abc')
  
  #其中 s 是对象, str 是类
  

• 面向对象的三大特性
  • 封装
  • 继承
  • 多态

类和对象的创建

• 类的定义
  • 使用class关键字来定义类，class关键字之后是一个空格，然后是类的名字，再然后是一个冒号，最后换行并定义类的内部实现。

    class classname:
      initializer #初始化
      methods #定义方法
    

• 创建对象
  • 定义了类之后，可以用来是实例化对象，并通过“对象名.成员名”的方式来访问其中的数据成员或成员方法。
  • 在Python中，可以使用内置方法**isinstance()**来测试一个对象是否为某个类的实例。
  • 对象成员是指它的数据（属性）和方法，数据也成为实例变量。
• 关于类和对象的变量（数据、属性）
  • 类中的每个变量都必须有初始值，哪怕这个值是0或空字符串。
• 变量值的修改
  • 直接通过对象进行修改。
  • 通过方法进行设置。
• 举例：

  class Student:  #学生类：包含成员变量和成员方法
    def __init__(self, mname, mnumber): #构造方法
        self.name = mname   #成员变量
        self.number = mnumber
        self.gpa = 0
  
    def getInfo(self):  #getInfo()方法用于打印姓名和学号
        print(self.name, self.number)
  
    def setGpa(self, gpa):  #setGpa()用于设置gpa变量
        self.gpa = gpa
  
  s4 = Student("Lei", "31000014") #创建s4变量
  s4.gpa = 3.8                    #直接通过对象进行修改
  print("我的名字是"+s4.name+"学号为"+s4.number, ",平均绩点为", s4.gpa)
  
  s5 = Student("Sun", "31000015") #创建s5对象
  s5.setGpa(3.6)                  #通过方法进行设置
  print("我的名字是"+s5.name+"学号为"+s5.number, ",平均绩点为", s5.gpa)
  

• Python类中成员：
  • 方法（函数）
    • 公有方法
    • 私有方法：方法名以两个下划线为前缀
    • 类方法：@classmethod
    • 静态方法：@staticmethod
  • 变量（数据）
    • 类变量
      • 是在类中所有方法之外定义的
    • 实例变量
      • 一般指在构造方法__init__()中定义的，定义和使用时以self为前缀。
    • 特性
      • 在主程序中（或类的外部），实例变量属于实例（对象），只能通过对象名访问；而类变量属于类，可以通过类名或对象名都可以访问。

使用对象编写程序

封装

• 封装
  • 将数据和对数据的操作组合起来构成类，类是一个不可分割的独立单位。
  • 类中既要提供与外部联系的接口，同时又要尽可能隐藏类的实现细节。
  • Python类中成员分为变量（数据、属性）和方法（函数）。
• 实例方法
  • 在类的方法中第一个参数如果为self，这种方法称为实例方法。
  • 实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。
• 类方法
  • Python允许声明属于类本身的方法，即类方法。
  • 类方法不对特定的实例进行操作，在类方法中不能访问对象的实例变量。
  • 类方法通过装饰器 @classmethod 来定义，第一个形式参数必须为类对象本身，通常为cls。
• 私有成员与公有成员
  • Python类的成员没有访问控制权限。
  • 在Python中通常有一些约定，在一下划线开头的方法名和变量名有特殊的含义，尤其是在类的定义中。
    • _xxx：受保护成员，不能用 from module import * 导入
    • __ xxx __：系统定义的特殊成员
    • __xxx ：私有成员，只有类自己能访问，不能使用对象直接访问到这个成员。
• 举例

  class Car1:
    price = 3000000             #定义类变量
  
    def __init__(self, name):   #构造方法
        self.__name = name      #定义实例变量
        self.__color = ""       #存储汽车颜色
  
    def setColor(self, color):
        self.__color = color
  
    def getName(self):          #打印汽车的名字和颜色
        print(self.__name, self.__color)
  
  car1 = Car1("奥迪")              #创建car1对象
  car1.setColor("黑色")            #car1的汽车颜色
  car1.getName()                  #打印car1的名字和颜色
  print(car1.price)               #打印汽车的价格
  

继承和多态

• 继承
  • 从一个通用类（父类），扩展更多特定的类（子类）
  • 举例：
• 多态
  • 子类的对象可以传递给需要父类类型的参数。一个方法可以被沿着继承链的几个类，运行时由Python决定调用哪个方法，这也称为动态绑定。
  • 举例：

    >>> 12+6
    18
    >>> '12'+'6'
    '126'
    

Web应用程序开发和网络爬虫

Web应用程序开发概述

• Web应用程序开发概述
  • Web应用程序是一种可以通过浏览器访问的应用程序。
  • 这种程序开发也被称为App开发。
  • Web应用程序现在主要采用浏览器/服务器架构（Browser/Server，简称B/S），它能够很好地应用在广域网上，成为越来越多企业的选择。
• Web应用程序的运行过程
  1. 运行用Python编写的服务程序
  2. 用户在浏览器输入URL访问某个资源
  3. Flask接受用户请求分析URL
  4. 为这个URL找到对应的处理函数
  5. 执行函数并生成响应，返回给浏览器
  6. 浏览器接受并解析响应，将信息显示在页面中
• URL 统一资源定位符
  • 统一资源定位符（Uniform Resource Locator）
  • 一般格式：
    protocol://hostname[:port]/path/[;parameters][?query]#fragment
    1. protocol：协议，例如百度就是https协议
    2. hostname[:port]：主机名（端口号可选参数），Flask默认的端口号为5000，百度的主机名就是：www.baidu.com
    3. path：主机资源的具体位置，如目录和文件名等。

Web应用框架Flask和文件模板

• Flask
  • Flask是一个使用Python编写的轻量级Web应用框架，其WSGI工具箱采用Werkzeug，模板引擎则使用Jinja2.Flask使用BSD授权
  • Flask也被称为“microframework”，因为它使用简单的核心，用扩展增加其他功能。
  • Flask是第三方模块，需要先安装才能使用。
• URL分析和对应的处理函数
  1. 运行Python服务程序
  2. 用户在浏览器输入URL，访问某个资源。
  3. Flask接受用户请求分析URL
  4. 为这个URL找到对应的处理函数
  5. 执行函数并生成响应，返回给浏览器
  6. 浏览器接受并解析响应，将信息显示在页面中
• 多个URL对应同一个函数
  • 多个URL可对应同一个函数，这样在浏览器中输入不同的URL返回结果是一样的
• HTTP协议常用请求
  • GET：从服务器程序获取信息
  • POST：
    • 通常用作向服务器程序发送数据，一般用表单实现
    • POST请求可能会导致新的资源的建立和/或已有资源的修改
• 浏览器和服务器程序交互
  • 浏览器和服务器程序交互可以通过get和post方法实现
  • 在装饰器上可以加上http方法，常用的是get和post方法，缺省的是get方法
  • @app.route("/")就等同于@app.route("/",methods=[“get”])
  • 如需要用两个方法，可写成：@app.route("/",methods=[“get”,“post”])
  • get和post是站在浏览器角度看的
• url_for()函数
  • 获取静态文件URL
  • 举例：

    url_for('ststic',filename='css/bootstrap.css')
    # 表示文件的URL是：/static/css/bootstrap.css
    # 根目录就是python所在的目录
    

云端部署Web应用程序

网络爬虫

• 安装requests-html模块
• 获取网页：

  from requests_html import HTMLSession
  Session = HTMLSession() #创建会话
  url = 'https://etf50.pythonanywhere.com'  #设置网址
  r = session.get(url)  #返回获取的网页对象
  print(r.html.html)  #调用r的html方法获取网页