• Python
  • Python 基础
    • Python介绍
    • 基础语句
    • 变量
    • 变量名称
    • 全局变量
  • 数据类型
    • Casting
    • 字符串
      • 字符串方法
    • 布尔值
    • 运算符(Operator)
    • 集合
      • 列表 (list)
      • 元组(tuple)
      • 集合(set)
      • 字典(Dictionary)
    • If…Else
    • 循环(Cycle)
  • 函数
    • 参数
    • 递归
    • lambda函数
      • 为何使用 Lambda 函数？
  • 数组
  • 类/对象
    • 创建
    • init() 函数
  • 继承
  • super() 函数
  • 添加属性
  • 添加方法
  • 迭代（Iterator）
    • 创建迭代器
    • StopIteration()
  • 作用域(scope)
    • 局部作用域
    • 全局作用域
    • 重名变量
    • global()
  • 模块
    • 创建模块
    • 使用模块
    • 重命名模块
    • dir() 函数
    • 从模块导入部件
  • 日期
  • JSON
    • 把 JSON 转换为 Python
    • 把 Python 转换为 JSON
    • 格式化结果
  • RegEx 模块
    • findall() 函数
    • Match 对象
  • PIP模块
    • 什么是包（Package）？
    • 安装包
    • 使用包
    • 删除包
    • 列出包
  • Try Except
    • 引发异常
  • 命令行输入
  • 字符串格式化
    • 字符串 format()
  • 文件处理
    • 打开文件
    • 读取文件
    • 关闭文件
    • 文件的写入或创建
    • 文件删除

Python

Python 基础

Python介绍

它用于：

• Web 开发（服务器端）
• 软件开发
• 数学
• 系统脚本

Python 可以做什么？

• 可以在服务器上使用 Python 来创建 Web 应用程序。
• Python 可以与软件一起使用来创建工作流。
• Python 可以连接到数据库系统。它还可以读取和修改文件。
• Python 可用于处理大数据并执行复杂的数学运算。
• Python 可用于快速原型设计，也可用于生产就绪的软件开发。

基础语句

变量

变量是存放数据值的容器。

与其他编程语言不同，Python 没有声明变量的命令。首次为其赋值时，才会创建变量。变量不需要使用任何特定类型声明，甚至可以在设置后更改其类型。

字符串变量可以使用单引号或双引号进行声明：

x = "bill"
x = 'bill'
x, y, z = "Orange", "Banana", "Cherry"
x = y = z = "Orange"

变量名称

变量可以使用短名称（如 x 和 y）或更具描述性的名称（age、carname、total_volume）。

Python 变量命名规则：

• 变量名必须以字母或下划线字符开头
• 变量名称不能以数字开头
• 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
• 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）

请记住，变量名称区分大小写

全局变量

• 在函数外部创建的变量（如上述所有实例所示）称为全局变量。全局变量可以被函数内部和外部的每个人使用。
• 如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。
• 通常，在函数内部创建变量时，该变量是局部变量，只能在该函数内部使用。要在函数内部 ==创建或者更改全局变量== ，您可以使用 global 关键字。global x

数据类型

Casting

==指定变量类型==

有时您可能需要为变量指定类型。这可以通过 casting 来完成。 Python 是一门面向对象的语言，因此它使用类来定义数据类型，包括其原始类型。

使用构造函数完成在 python 中的转换：

• int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字的字符串字面量
• float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
• str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量

字符串

字符串是数组

像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。方括号可用于访问字符串的元素。

字符串方法

布尔值

• bool()

  • 大多数值都为 True.如果有某种内容，则几乎所有值都将评估为 True。

  • 除空字符串外，任何字符串均为 True。

  • 除 0 外，任何数字均为 True。

  • 除空列表外，任何列表、元组、集合和字典均为 True。

运算符(Operator)

Python 在以下组中划分运算符：

• 算术运算符

  

• 赋值运算符

  &	按位与
  |	按位或
  ^	按位异或
  ~	按位取反
  «	按位左移
  »	按位右移

• 比较运算符

• 逻辑运算符

• 身份运算符

• 成员运算符

• 位运算符

集合

Python 编程语言中有四种集合数据类型：

• 列表（List）是一种有序和可更改的集合。允许重复的成员。thislist = ["apple", "banana", "cherry"]

• 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。thistuple = (“apple”, “banana”, “cherry”)

• 集合（Set）是一个无序和无索引的集合。没有重复的成员。thisset = {“apple”, “banana”, “cherry”}

• 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。

• thisdict =	{
    "brand": "Porsche",
    "model": "911",
    "year": 1963
  }
  

列表 (list)

元组(tuple)

• 需创建仅包含一个项目的元组，您必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。

  

集合(set)

• 集合是无序的，因此您无法确定项目的显示顺序。

• 您无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。 但是您可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。

• 集合一旦创建，您就无法更改项目，但是您可以添加新项目。

  • 要将一个项添加到集合，请使用 add() 方法。thisset.add("orange")

    要向集合中添加多个项目，请使用 update() 方法。thisset.update(["orange", "mango", "grapes"])

• 要删除集合中的项目，请使用 remove() 或 discard() 方法。

  • 使用 remove() 方法来删除 “banana”：thisset.remove(“banana”)
    • 注释：如果要删除的项目不存在，则 remove() 将引发错误。
  • 使用 discard() 方法来删除 “banana”：thisset.discard(“banana”)
    • 注释：如果要删除的项目不存在，则 discard() 不会引发错误。
  • 您还可以使用 pop() 方法删除项目，但此方法将删除最后一项。请记住，set 是无序的，因此您不会知道被删除的是什么项目。pop() 方法的返回值是被删除的项目。

字典(Dictionary)

If…Else

循环(Cycle)

• while 循环,如果使用 while 循环，只要条件为真，我们就可以执行一组语句.

  i = 1
  while i < 7:
    print(i)
    i += 1
  

  • 请记得递增 i，否则循环会永远继续。
  • while 循环需要准备好相关的变量。
  • 如果使用 break 语句，即使 while 条件为真，我们也可以停止循环：
  • 如果使用 continue 语句，我们可以停止当前的迭代，并继续下一个：
  • 通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块：

• For 循环,for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

  fruits = ["apple", "banana", "cherry"]
  for x in fruits:
    print(x)
  

  • 如需循环一组代码指定的次数，我们可以使用 range() 函数，

    • range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。
    • range(3, 10)，这意味着值为 3 到 10（但不包括 10）
    • range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)
    • range(10) 不是 0 到 10 的值，而是值 0 到 9。

  • for 循环中的 else 关键字指定循环结束时要执行的代码块

  • 嵌套循环是循环内的循环。

    “外循环”每迭代一次，“内循环”将执行一遍：

  • pass语句

  • enumerate() 函数可以在遍历序列时同时获取索引和值:

   for index, fruit in enumerate(fruits):
       print(f"索引 {index}: {fruit}")
  

  • zip() 函数可以同时遍历多个序列。

   names = ["Alice", "Bob", "Charlie"]
   ages = [25, 30, 35]
     
   for name, age in zip(names, ages):
       print(f"{name} 的年龄是 {age} 岁")
  

函数

定义函数:使用 def 关键字定义函数

def my_function():
  print("Hello from a function")

调用函数:my_function()

参数

信息可以作为参数传递给函数。

参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。

下面的例子有一个带参数（fname）的函数。当调用此函数时，我们传递一个名字，在函数内部使用它来打印全名：

def my_function(fname):
  print(fname + " Gates")

my_function("Bill")
my_function("Steve")
my_function("Elon")

• 默认参数:def my_function(country = "China"):

• 您发送到函数的参数可以是任何数据类型（字符串、数字、列表、字典等），并且在函数内其将被视为相同数据类型

• 如需使函数返回值，请使用 return 语句：

  def my_function(x):
    return 5 * x
  

• 关键字参数( kwargs):您还可以使用 key = value 语法发送参数。

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

• 如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。

  这样，函数将接收一个参数元组，并可以相应地访问各项:def my_function(*kids):

递归

lambda函数

lambda 函数是一种小的匿名函数。

lambda 函数可接受任意数量的参数，但只能有一个表达式。

lambda arguments : expression

x = lambda a, b, c : a + b + c

为何使用 Lambda 函数？

当您把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。

def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)
mytripler = myfunc(3)

print(mydoubler(11)) 
print(mytripler(11))

数组

请注意，Python 没有内置对数组的支持，但可以使用 Python 列表代替。

类/对象

Python 是一种面向对象的编程语言。

Python 中的几乎所有东西都是对象，拥有属性和方法。

类（Class）类似对象构造函数，或者是用于创建对象的“蓝图”。

创建

创建类:如需创建类，请使用 class 关键字：

class MyClass:
  x = 5

现在我们可以使用名为 myClass 的类来创建对象：

p1 = MyClass()
print(p1.x)

init() 函数

所有类都有一个名为 init() 的函数，它始终在启动类时执行。

使用 init() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作：

**注释：**每次使用类创建新对象时，都会*自动调用* __init__() 函数。

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

# 使用 Person 来创建对象，然后执行 printname 方法：

x = Person("Bill", "Gates")
x.printname()

#创建一个名为 Person 的类，其中包含 firstname 和 lastname 属性以及 printname 方法

为什么需要 self？

• Python 通过 self 明确区分对象的属性和局部变量。

• 如果没有 self，name 只是一个局部变量，无法在类的其他方法中访问。

• self 参数是对类的当前实例的引用，用于访问属于该类的变量。

  它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数

继承

继承允许我们定义继承另一个类的所有方法和属性的类。

父类是继承的类，也称为基类。

子类是从另一个类继承的类，也称为派生类。

子类:

class Student(Person):
  pass

现在，Student 类拥有与 Person 类相同的属性和方法。

class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

• 当您添加 init() 函数时，子类将不再继承父的 init() 函数。

​ 注释：子的 init() 函数会覆盖对父的 init() 函数的继承。

​ 如需保持父的 init() 函数的继承，请添加对父的 init() 函数的调用

• super() 函数

通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

• 添加属性

• 添加方法

迭代（Iterator）

迭代器是一种对象，该对象包含值的可计数数字。

迭代器是可迭代的对象，这意味着您可以遍历所有值。

从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 iter() 和 next()。

• iter() 和 next()

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))

• for ()

创建迭代器

要把对象/类创建为迭代器，必须为对象实现 __iter__() 和 __next__() 方法。

正如您在 Python 类/对象 一章中学到的，所有类都有名为 __init__() 的函数，它允许您在创建对象时进行一些初始化。

• __iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。
• __next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

StopIteration()

如果你有足够的 next() 语句，或者在 for 循环中使用，则上面的例子将永远进行下去。

为了防止迭代永远进行，我们可以使用 StopIteration 语句。

在 __next__() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误：

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

作用域(scope)

变量仅在创建区域内可用。这称为作用域。

局部作用域

在函数内部创建的变量属于该函数的局部作用域，并且只能在该函数内部使用。

def myfunc():
  x = 100
  print(x)

myfunc()

全局作用域

在 Python 代码主体中创建的变量是全局变量，属于全局作用域。

全局变量在任何范围（全局和局部）中可用。

重名变量

如果在函数内部和外部操作同名变量，Python 会将它们视为两个单独的变量，一个在全局范围内可用（在函数外部），而一个在局部范围内可用（在函数内部）

global()

模块

创建模块

.py

使用模块

import module_name 调用模块

module_name.function_name 调用模块中的函数

重命名模块

import mymodule as mx

dir() 函数

dir() 函数可以列出模块中的所有函数名（或变量名）。

从模块导入部件

您可以使用 from 关键字选择仅从模块导入部件。

from mymodule import person1

print (person1["age"])

日期

Python 中的日期不是其自身的数据类型，但是我们可以导入名为 datetime 的模块，把日期视作日期对象进行处理。

import datetime

x = datetime.datetime.now()
print(x)

• 创建日期对象

datetime() 类需要三个参数来创建日期：年、月、日。

x = datetime.datetime(2020, 5, 17)

• strftime() 方法

datetime 对象拥有把日期对象格式化为可读字符串的方法。

该方法称为 strftime()，并使用一个 format 参数来指定返回字符串的格式：

import datetime

x = datetime.datetime(2019, 10, 1)

print(x.strftime("%B"))

JSON

JSON 是用于存储和交换数据的语法。

JSON 是用 JavaScript 对象表示法（JavaScript object notation）编写的文本。

把 JSON 转换为 Python

若有 JSON 字符串，则可以使用 json.loads() 方法对其进行解析。

结果将是 Python 字典。

import json

# 一些 JSON:
x =  '{ "name":"Bill", "age":63, "city":"Seatle"}'

# 解析 x:
y = json.loads(x)

# 结果是 Python 字典：
print(y["age"])

把 Python 转换为 JSON

若有 Python 对象，则可以使用 json.dumps() 方法将其转换为 JSON 字符串。print(json.dumps(x))

您可以把以下类型的 Python 对象转换为 JSON 字符串：

格式化结果

RegEx 模块

RegEx 或正则表达式是形成搜索模式的字符序列。

RegEx 可用于检查字符串是否包含指定的搜索模式。

# 检索字符串以查看它是否以 "China" 开头并以 "country" 结尾：
import re

txt = "China is a great country"
x = re.search("^China.*country$", txt)

findall() 函数

findall() 函数返回包含所有匹配项的列表。

import re

str = "China is a great country"
x = re.findall("a", str)
print(x)

Match 对象

Match 对象是包含有关搜索和结果信息的对象。

注释：如果没有匹配，则返回值 None，而不是 Match 对象。

Match 对象提供了用于取回有关搜索及结果信息的属性和方法：

• span() 返回的元组包含了匹配的开始和结束位置
• .string 返回传入函数的字符串
• group() 返回匹配的字符串部分

PIP模块

PIP 是 Python 包或模块的包管理器。

注释：如果您使用的是 Python 3.4 或更高版本，则默认情况下会包含 PIP。

什么是包（Package）？

包中包含模块所需的所有文件。

模块是您可以包含在项目中的 Python 代码库。

安装包

pip install camelcase

使用包

import camelcase

删除包

pip uninstall camelcase

列出包

pip list

Try Except

try 块允许您测试代码块以查找错误。

except 块允许您处理错误。

finally 块允许您执行代码，无论 try 和 except 块的结果如何。

try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")
else:
  print("Nothing went wrong")
finally:
  print("The 'try except' is finished")

• try 块将生成异常，因为 x 未定义
• 由于 try 块引发错误，因此会执行 except 块。
• 如果没有 try 块，程序将崩溃并引发错误
• 您可以根据需要定义任意数量的 exception 块，例如，假如您要为特殊类型的错误执行特殊代码块. 如果 try 块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息
• 如果没有引发错误，那么您可以使用 else 关键字来定义要执行的代码块
• 如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块

引发异常

作为 Python 开发者，您可以选择在条件发生时抛出异常。

如需抛出（引发）异常，请使用 raise 关键词。

raise 关键字用于引发异常。您能够定义所引发异常的类型、以及打印给用户的文本。

x = -1

if x < 0:
  raise Exception("Sorry, no numbers below zero")

命令行输入

Python 允许命令行输入。这意味着我们能够要求用户输入。

Python 3.6 中的方法与 Python 2.7 略有不同。Python 3.6 使用 input() 方法。Python 2.7 使用 raw_input() 方法。

字符串格式化

字符串 format()

format() 方法允许您格式化字符串的选定部分。

有时文本的一部分是你无法控制的，也许它们来自数据库或用户输入？

要控制此类值，请在文本中添加占位符（花括号 {}），然后通过 format() 方法运行值

price = 52
txt = "The price is {} dollars"
print(txt.format(price))

quantity = 3
itemno = 567
price = 52
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))

myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Porsche", model = "911"))

文件处理

打开文件

在 Python 中使用文件的关键函数是 open() 函数。

open() 函数有两个参数：文件名和模式。

有四种打开文件的不同方法（模式）：

• "r" - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错。
• "a" - 追加 - 打开供追加的文件，如果不存在则创建该文件。
• "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件。
• "x" - 创建 - 创建指定的文件，如果文件存在则返回错误。

此外，您可以指定文件是应该作为二进制还是文本模式进行处理。

• "t" - 文本 - 默认值。文本模式。
• "b" - 二进制 - 二进制模式（例如图像）。

f = open("demofile.txt", "rt")

读取文件

如需打开文件，请使用内建的 open() 函数。

open() 函数返回文件对象，此对象有一个 read() 方法用于读取文件的内容：

f = open("demofile.txt", "r")
print(f.read())
#默认情况下，read() 方法返回整个文本，但您也可以指定要返回的字符数：
print(f.read(5))
#您可以使用 readline() 方法返回一行：两次调用即读取前两行
print(f.readline())
#通过循环遍历文件中的行，您可以逐行读取整个文件：
f = open("demofile.txt", "r")
for x in f:
  print(x)

关闭文件

f.close()

文件的写入或创建

如需写入已有的文件，必须向 open() 函数添加参数：

• "x" - 创建 - 将创建一个文件，如果文件存在则返回错误
• "a" - 追加 - 会追加到文件的末尾
• "w" - 写入 - 会覆盖任何已有的内容

f = open("demofile2.txt", "a")
f.write("Now the file has more content!")
f.close()
#注释："w" 方法会覆盖全部内容。
f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!")
f.close()

文件删除

如需删除文件，必须导入 OS 模块，并运行其 os.remove() 函数：

imp
ve("demofile.txt")

#检查文件是否存在，然后删除它：
import os
if os.path.exists("demofile.txt"):
  os.remove("demofile.txt")
else:
  print("The file does not exist")
#如需删除整个文件夹，请使用 os.rmdir() 方法：                            提示：您只能删除空文件夹。
import os
os.rmdir("myfolder")