Python教程

多行注释用三个单引号（'''）或者三个双引号（"""）将需要注释的内容囊括起来

变量

python没有声明变量的命令，变量不需要任何特定类型声明，甚至可以在设置后更改其类型.

x = 5 # x is of type int
x = "Steven" # x is now of type str
print(x)

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

x = "Bill" # is the same as
x = 'Bill'

python变量命名规则：

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

Python允许一行中为多个变量赋值

x, y, z = "Orange", "Banana", "Cherry"
print(x)
print(y)
print(z)

输出变量print, 如需结合文本和变量， 使用+字符

x = "awesome"
print("Python is " + x)

在函数内部创建全局变量，使用global关键字

def myfunc():
  global x
  x = "fantastic"
myfunc()
print("Python is " + x)

数据类型

变量可以存储不同类型的数据，并且不同类型可以执行不同的操作

python默认内置数据类型

文本类型：	str
数值类型：	int, float, complex
序列类型：	list, tuple, range
映射类型：	dict
集合类型：	set, frozenset
布尔类型：	bool
二进制类型：	bytes, bytearray, memoryview

使用type获取任何对象的数据类型

x = 10
print(type(x))

如果希望指定数据类型，则可以使用一下构造函数

x = str("Hello World")
x = int(29)
x = list(("apple", "banana", "cherry"))
x = bool(5)

类型转换：使用int() float() complex()方法从一种类型转换成另一种类型

#convert from int to float:
x = float(10)
#convert from float to int:
y = int(6.3)
#convert from int to complex:
z = complex(x)
print(x)
print(y)
print(z)

Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数

导入 random 模块，并显示 1 到 9 之间的随机数：

import random

print(random.randrange(1,10))

字符串

Python中的字符串字面量由单引号或双引号，使用三个引号将多行字符串赋值给变量

a = """Python is a widely used general-purpose, high level programming language. 
It was initially designed by Guido van Rossum in 1991 
and developed by Python Software Foundation. """
print(a)
print(a[1]) #字符串是数组

裁剪：返回一定范围的字符。指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分

b = "Hello world!"
print(b[2:5])
print(len(a)) #获取字符串长度

负索引：从字符串末尾开始切片

Python 中的字符串有两种索引方式，第一种是从左往右，从 0 开始依次增加；第二种是从右往左，从 -1 开始依次减少。

#获取从位置5到位置1的字符，从字符串末尾开始计数
a = "Hello, world!"
print(a[-5:-2])

字符串方法：Python有一组可用于字符串的内置方法

strip()方法删除开头和结尾的空白字符

a = " Hello, World! "
print(a.strip()) # return "Hello, World!"

lower() 返回小写的字符串, upper() 方法返回大写的字符串

a = "Hello, World!"
print(a.lower())
print(a.upper())

replace() 用另一段字符串来替换字符串：

a = "Hello, World!"
print(a.replace("World", "Kitty"))

split() 方法在找到分隔符的实例时将字符串拆分为子字符串：

a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']

检查字符串：检查字符串中是否存在特定短语或字符，使用in 或not in关键字，返回值是bool类型

txt = "China is a great country"
x = "ina" in txt
print(x)
# 检查一下文本中是否没有短语"ain"
txt = "China is a great country"
x = "ain" not in txt
print(x) 

使用 format() 方法组合字符串和数字, format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中：

使用 format() 方法将数字插入字符串：

age = 63
txt = "My name is Bill, and I am {}"
print(txt.format(age))

函数可返回布尔: python有很多返回布尔值的内置函数，如isinstance()可用于确定对象是否具有某种数据类型。

#检查对象是否是整数
x = 200
print(isinstance(x, int)) # return True

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

• 列表（List）是一种有序和可更改的集合。允许重复的成员。
• 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
• 集合（Set）是一个无序和无索引的集合。没有重复的成员。
• 词典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。

列表

列表是一个有序且可更改的集合，可以通过索引号来访问列表项。负索引表示从末尾开始，-1表示最后一个项目，-2表示倒数第二个项目

thislist = ["apple", "banana", "cherry"]
print(thislist)
print(thislist[1])
# 打印列表最后一项
print(thislist[-1])

返回第三、第四、第五项：

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5]) #搜索将从索引 2（包括）开始，到索引 5（不包括）结束

负索引：从列表末尾开始搜索

# 返回从索引-4(包括)到索引-1(排除)的项目
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[-4:-1]) # return ['orange', 'kiwi', 'melon']

遍历列表：使用for循环遍历列表项

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

append()方法将项目添加到列表的末尾

thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

insert()方法在指定的索引处添加项目

thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange")
print(thislist)

remove()方法删除指定的项目

thislist = ["apple", "banana", "cherry"]
thislist.remove("banana")
print(thislist)

pop() 方法删除指定的索引（如果未指定索引，则删除最后一项）

thislist = ["apple", "banana", "cherry"]
thislist.pop()
print(thislist)

del 关键字删除指定的索引

thislist = ["apple", "banana", "cherry"]
del thislist[0]
print(thislist)
# del 关键字也能完整地删除列表
del thislist
#clear()方法清空列表
thislist.clear()

复制列表copy() list()

thislist = ["apple", "banana", "cherry"]
mylist = thislist.copy()
print(mylist)

mylist = list(thislist)
print(mylist)

合并列表，extend()方法将一个列表中的元素添加到另一个列表中

# 将 list2 添加到 list1 的末尾
list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

使用 list() 构造函数创建列表

thislist = list(("apple", "banana", "cherry")) # 请注意双括号
print(thislist)

元组

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

元组是有序且不可更改的集合

创建元组

thistuple = ("apple", "banana", "cherry")
print(thistuple)

更改元组值：创建元组后，将无法更改其值。元组是不可变的。但可将元组转换为列表，更改列表，然后将列表转换回元组。

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
print(x)

遍历元组：

thistuple = ("apple", "banana", "cherry")
for x in thistuple:
  print(x)

元组是不可更改的，因此无法从中删除项目，但可以完全删除元组

thistuple = ("apple", "banana", "cherry")
del thistuple

print(thistuple) # 这会引发错误，因为元组已不存在。

使用tuple()构造函数来创建元组

thistuple = tuple(("apple", "banana", "cherry")) # 请注意双括号
print(thistuple)

集合

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。

创建集合：

thisset = {"apple", "banana", "cherry"}
print(thisset)

遍历集合：

thisset = {"apple", "banana", "cherry"}

for x in thisset:
  print(x)

# 检查 set 中是否存在 “banana”：
print("banana" in thisset)

集合一旦创建，将无法更改项目，但可以添加新项目

添加项目：add()方法将一个项目添加到集合，update()方法向集合中添加多个项目

thisset = {"apple", "banana", "cherry"}

thisset.add("orange")

print(thisset)

thisset.update(["orange", "mango", "grapes"])

print(thisset)

删除项目：remove()和discard()方法

thisset = {"apple", "banana", "cherry"}

thisset.remove("banana")

print(thisset)

注意：如果删除的项目不存在，则remove()将引发错误

使用 discard() 方法来删除 “banana”：

thisset = {"apple", "banana", "cherry"}

thisset.discard("banana")

print(thisset)

clear()方法清空集合

thisset = {"apple", "banana", "cherry"}

thisset.clear()

print(thisset)

del彻底删除集合

thisset = {"apple", "banana", "cherry"}

del thisset

print(thisset)

合并两个集合：

union() 方法返回包含两个集合中所有项目的新集合

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

update() 方法将 set2 中的项目插入 set1 中

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)

使用set()构造函数来创建集合

thisset = set(("apple", "banana", "cherry")) # 请留意这个双括号
print(thisset)

字典

字典是一个无序、可变和有索引的集合

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
print(thisdict)

可以通过在方括号内引用其键名来访问字典的项目

# 获取 "model" 键的值
x = thisdict["model"]

x = thisdict.get("model")

可以通过引用其键名来更改特定项的值：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict["year"] = 2019

遍历字典：

# 逐个打印字典中的所有键名
for x in thisdict:
  print(x)

#逐个打印字典中的所有值：

for x in thisdict:
  print(thisdict[x])

可以使用 values() 函数返回字典的值：

for x in thisdict.values():
  print(x)

通过使用 items() 函数遍历键和值：

for x, y in thisdict.items():
  print(x, y)

添加项目：

通过使用新的索引键并为其赋值，可以将项目添加到字典中：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict["color"] = "red"
print(thisdict)

删除项目：

pop() 方法删除具有指定键名的项：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
thisdict.pop("model")
print(thisdict)

thisdict.popitem()
print(thisdict)

popitem() 方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）

del 关键字删除具有指定键名的项目，也可以完全删除字典

del thisdict["model"]
del thisdict

clear() 关键字清空字典

thisdict.clear()

复制字典：

使用copy()方法来复制字典：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = thisdict.copy()
print(mydict)

使用 dict() 方法创建字典的副本：

thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
mydict = dict(thisdict)
print(mydict)

嵌套字典：字典可以包含许多字典

# 创建包含三个字典的字典
myfamily = {
  "child1" : {
    "name" : "Phoebe Adele",
    "year" : 2002
  },
  "child2" : {
    "name" : "Jennifer Katharine",
    "year" : 1996
  },
  "child3" : {
    "name" : "Rory John",
    "year" : 1999
  }
}

使用dict()构造函数创建新的字典

thisdict = dict(brand="Porsche", model="911", year=1963)
# 请注意，关键字不是字符串字面量
# 请注意，使用了等号而不是冒号来赋值
print(thisdict)

range() 函数循环一组代码指定的次数。返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

for x in range(10):
  print(x)  #输出数字0-9

函数

使用 def 关键字定义函数：

def my_function():
  print("Hello from a function")
my_function() #调用函数

以列表List传参

def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

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

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Phoebe", "Jennifer", "Rory")

递归函数：

def tri_recursion(k):
  if(k>0):
    result = k+tri_recursion(k-1)
    print(result)
  else:
    result = 0
  return result

print("\n\nRecursion Example Results")
tri_recursion(6)

Lambda

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

语法：lambda arguments : expression

# 一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果
x = lambda a : a + 10
print(x(5))

# 一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果
x = lambda a, b : a * b
print(x(5, 6))

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

mydoubler = myfunc(2)

print(mydoubler(11))

在同一程序中使用相同的函数定义来生成两个函数:

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

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

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

类/对象

# 创建一个名为MyClass的类
class MyClass:
    x=5
# 创建一个名为p1的对象, 并打印x的值
p1 = MyClass()
print(p1.x)

init()在类实例化时会自动调用

init() 函数(理解为C++中默认构造函数，做初始化工作)

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

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

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数。类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称self

# 创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值
class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("Bill", 63)

print(p1.name)
print(p1.age)

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

对象方法：

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("Bill", 63)
p1.myfunc()

提示：self 参数是对类的当前实例的引用，用于访问属于该类的变量（理解为C++中this指针）

删除对象属性：使用del 关键字删除对象的属性

# 删除p1对象的age属性
del p1.age

删除对象：使用del关键字删除对象

# 删除p1对象
del p1

self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

执行结果：

<__main__.Test instance at 0x100771878>
__main__.Test

继承

类的私有属性:

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

创建父类：

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

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()

创建一个名为 Student 的类，它将从 Person 类继承属性和方法：

class Student(Person):
  pass   # 如果不想向类添加任何其他属性或方法，使用pass关键字

super函数是子类从其父类继承所有方法和属性

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

添加属性：

把名为 graduationyear 的属性添加到 Student 类：

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

x = Student("Elon", "Musk", 2019)

迭代器

迭代器是一种对象，该对象包含值的可计数数字。迭代器是可迭代的对象，这意味着您可以遍历所有值。

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

列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

所有这些对象都有用于获取迭代器的 iter() 方法。

# 从元组返回一个迭代器，并打印每个值：
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

遍历迭代器：

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

for x in mytuple:
  print(x)

提示：for 循环实际上创建了一个迭代器对象，并为每个循环执行 next() 方法

模块

模块是包含一组函数的文件，希望在应用程序中引用

创建模块：如需创建模块，只需将所需代码保存在文件扩展名为.py的文件中

在名为 mymodule.py 的文件中保存代码：

def greeting(name):
  print("Hello, " + name)

使用模块：import语句来使用创建的模块

导入名为 mymodule 的模块，并调用 greeting 函数

import mymodule

mymodule.greeting("Bill")

模块中的变量：

在文件 mymodule.py 中保存代码：

person1 = {
  "name": "Bill",
  "age": 63,
  "country": "USA"
}

导入名为 mymodule 的模块，并访问 person1 字典：

import mymodule

a = mymodule.person1["age"]
print(a)

重命名模块：可以在导入模块时使用as关键字创建别名

为 mymodule 创建别名 mx：

import mymodule as mx

a = mx.person1["age"]
print(a)

内建模块：Python中有几个内建模块，可以随时导入

导入并使用 platform 模块：

import platform

x = platform.system()
print(x)

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

列出属于 platform 模块的所有已定义名称：

import platform

x = dir(platform)
print(x)

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

名为 mymodule 的模块拥有一个函数和一个字典：

def greeting(name):
  print("Hello, " + name)

person1 = {
  "name": "Bill",
  "age": 63,
  "country": "USA"
}

仅从模块导入 person1 字典：

from mymodule import person1

print (person1["age"])

JSON

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

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

Python有一个名为json的内置包，用于处理JSON数据

导入JSON模块：import json

解析JSON---把JSON转换为Python：若有JSON字符串，则可以使用json.loads()方法对其进行解析，结果将是Python字典。

把 JSON 转换为 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字符串

把 Python 转换为 JSON：

import json

# Python 对象（字典）：
x = {
  "name": "Bill",
  "age": 63,
  "city": "Seatle"
}

# 转换为 JSON：
y = json.dumps(x)

# 结果是 JSON 字符串：
print(y)

正则表达式

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

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

RegEx模块：Python提供名为re的内置包，可用于处理正则表达式

导入re模块：

import re

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

import re

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

re 模块提供了一组函数，允许我们检索字符串以进行匹配：

函数	描述
findall	返回包含所有匹配项的列表
search	如果字符串中的任意位置存在匹配，则返回 Match 对象
split	返回在每次匹配时拆分字符串的列表
sub	用字符串替换一个或多个匹配项

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

打印所有匹配的列表：

import re

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

search()函数搜索字符串中的匹配项，如果存在则返回Mathc对象，如果有多个匹配则仅返回首个匹配项

在字符串中搜索第一个空白字符：

import re

str = "China is a great country"
x = re.search("\s", str)

print("The first white-space character is located in position:", x.start())

split() 函数返回一个列表，其中字符串在每次匹配时被拆分：

在每个空白字符处进行拆分：

import re

str = "China is a great country"
x = re.split("\s", str)
print(x)

sub() 函数把匹配替换为您选择的文本

用数字 9 替换每个空白字符：

import re

str = "China is a great country"
x = re.sub("\s", "9", str)
print(x)

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

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

执行会返回 Match 对象的搜索：

import re

str = "China is a great country"
x = re.search("a", str)
print(x) # 将打印一个对象

异常

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

except 块允许您处理错误。

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

#The try block will raise an error when trying to write to a read-only file:

try:
  f = open("demofile.txt")
  f.write("Lorum Ipsum")
except:
  print("Something went wrong when writing to the file")
finally:
  f.close()

#The program can continue, without leaving the file object open

raise 关键字用于引发异常

假如 x 小于 0，则引发异常并终止程序：

x = -1

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

命令输入：

print("Enter your name:")
x = input()
print("Hello ", x)

字符串格式化：为了确保字符串按预期显示，可以使用format()方法对结果进行格式化。

format() 方法允许您格式化字符串的选定部分。有时文本的一部分是你无法控制的，也许它们来自数据库或用户输入？要控制此类值，请在文本中添加占位符（花括号 {}），然后通过 format() 方法运行值

添加要显示价格的占位符：

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

文件处理

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

默认情况下，read() 方法返回整个文本，但您也可以指定要返回的字符数

返回文件中的前五个字符：

f = open("demofile.txt", "r")
print(f.read(5))

readline() 方法返回一行

读取文件中的一行：

f = open("demofile.txt", "r")
print(f.readline())

逐行遍历文件：

f = open("demofile.txt", "r")
for x in f:
  print(x)

关闭文件：

f = open("demofile.txt", "r")
print(f.readline())
f.close()

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

删除文件 "demofile.txt"：

import os
os.remove("demofile.txt")

删除文件夹：如需删除整个文件夹，使用os.rmdir()方法

删除文件夹 "myfolder"：

import os
os.rmdir("myfolder")  # 只能删除空文件夹