Python3初步实践教程概要

“人生苦短，快学Python”
“Life is short, you need Python!”
———— Bruce Eckel

Python作为一门脚本语言，功能是非常强大的，同时也拥有很多模块库，进行适当的调用接口将给我们带来很多便利。Python运用的场景非常多，例如人工智能、云计算、Web开发、爬虫技术、数据分析等。大名鼎鼎的Youtube、Instagram、Reddit（大多都是国外的App,国内还是以Java Go为主）等App均使用Python进行快速开发。
当然，python作为脚本语言速度方面远远不如Java,甚至是C/C++，目前流行的开发也将此进行融合，取长补短合理利用。
对于网络专业、数据专业的同学来说Python技术是必不可少的，具体体现在对于爬虫分析（抓包分析）、数据分析、安全防范等。

前言

主要分为3个模块，分别是基础语法、编程初步、高级编程。对于最基本的Python格式不再编写，例如缩进、格式等问题。对于学习过数据结构的同学对于基础语法也是很快掠过，重点掌握list set dict的用法。对于学习过面向对象语言（例如C++/Java)在编程初步上也会很快学习。对于学习过前端（html+css+javascript)、计算机网络、数据库的同学可以进入高级教程，以便于快速学习。
总之，此初步实践仅对Python大致范围有个熟悉，后面将一些实战为例继续巩固Python学习。

基础语法

import导入 将整个模块导入：import somemodule 从模块中导入某个函数：from somemodule import firstfun,secondfunction ,导入全部函数：ftrom somemodule import *

基本数据类型

变量不需要声明，但是使用前必须赋值，赋值后才会被创建。变量没有类型
六大标准数据类型：type(a) instance(a,int?)
Number String List Tuple Set Dictionary
数值计算 ：除法（/，得到一个浮点数） 除法（ //，得到一个整数），乘方（），复数计算可以用a+bj 或者 complex(a,b)
String :使用‘’ 或者"" 使用’’ 下标索引从0开始，-1为末尾开始的位置，可以截取
List ：数据类型可以不相同，写在[ ]，input[-1::-1] 第一个参数表示最后一个元素，第二元素为空表示移动到末尾，第三个参数为步长，-1表示逆向
Tuple :与List类似不同在于元组元素不能修改并且写在()里面。
Set:集合，使用{} 或者set()创建集合

para={value1,value2}
or
set(value1,value2)
1
2
3

差 - 并 | 补 &
Dictionary:键（唯一）值对（无序），映射类型，使用{ }标识

dict={}
tintdict={'name':1,'runbane':2}
1
2

数据类型转换

推导式

推导式是独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体，支持各种数据结构的推导式：list dict set tuple
列表推导式

[表达式 for 变量 in 列表  (if) 条件]
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']
1
2
3
4
5

字典推导式

{key_expr: val_exp for value in collection if condition}
listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

1
2
3
4
5
6
7

集合推导式

{express for item in Seque}
>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}
1
2
3
4

运算符

逻辑运算符 and (与) or (或) not (非)
成员运算符 in not in （+序列）

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
1
2
3
4
5
6
7

身份运算符 is not is (标识符) 例如 x is y 类似于 id(x) == id (y) 注意 id函数用于获取对象内存地址

数字Number

数据类型是不允许改变的，这就意味着如果改变数据类型的值，将重新分配内存。（必须先定义即赋予变量一个值）
随机数函数

字符串

单字符作为字符串，使用[]截取字符串，格式 变量 [头下标：尾下标]
以字符串Runoob为例：
从前面索引：0 1 2 3 4 5
从后面索引：-6 -5 -4 -3 -2 -1
从前面截取： : 1 2 3 4 5:
从后面截取: : -5 -4 -3 -2 -1:

字符串运算符 ： [] 索引获取 ； [:] 截取字符串一部分 ，遵循左闭右开原则，例如[0:2]不包含第三个字符
格式化

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
1

内置函数

列表

访问和字符串一样，索引从0开始，也可以从尾部开始，最后一个索引为-1，依次-1.可以使用[]截取字符。list[0:4]将输出从0到3的字符。
更新列表：可直接对数据项进行修改或更新，同时也可以选择append()添加列表项
删除列表：del list[2]
列表比较：operator.eq(list1,list2)
函数：len(list),max(list),min(list),list(seq)

元组

元组使用( ).记住元组是不可变的

字典

使用冒号进行分割，每个对之间使用逗号分隔，整个在{ }

str=input()
dir={}
for i in range(len(str)):
    if str[i] in dir:
        dir.update({str[i]:dir.get(str[i])+1})
    else :
        dir.update({str[i]:1})
print(dir)

1
2
3
4
5
6
7
8
9

集合

可以使用大括号或者set( )创建，注意创建一个空集合必须用set( )
集合基本操作：set.add(x) set.update(x) set.remove(x) set.discard(x)(删除指定元素)

编程初步

迭代器与生成器

迭代器是一个记住遍历位置的对象，从第一个元素开始知道被访问，并且只往前。
基本方法：iter(obj_name) 和 next(iter_name) 字符串、列表、元组都可以创建迭代器

class Exam:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        x=self.a
        self.a+=1
        return x

myc=Exam()
myiter=iter(myc)

print (next(myiter))
print (next(myiter))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

生成器
使用了yeild函数被称为生成器（generator)生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

函数

def max(a,b):
    return a
def 函数名（参数列表）:
    函数体
 
if __name__=="__main__":
    
1
2
3
4
5
6
7

参数：必需参数 关键字参数 默认参数 不定长参数

匿名函数 lambda，所谓匿名就是不再使用def，只是一个表达式

lambda [arg1 [,arg2,.....argn]]:expression

x=lambda a : a+10
print(x(5))

1
2
3
4
5

数据结构

列表

使用列表可以作为一个堆栈来使用 append()入栈 pop()出栈
使用列表当作队列，append()入队 popleft()第一个出队

遍历技巧

遍历字典
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)


1
2
3
4
5
6

模块

模块就是一个python文件
import导包同Java,
from … import *

name属性：如果我们想在模块被引入时，模块中的某一程序块不执行，来使该程序块仅在该模块自身运行时执行。

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')
1
2
3
4

包 A.B ：包A中的子模块B

输入和输出

输出：表达式 / print() / 文件的write()
str() :函数返回一个用户易读的表达形式
repr():产生一个解释器易读的表达形式
str.format()

print('{}1'.format('naio'))
print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
1
2

读取键盘输入
str=input()

读和写文件
open(filename,mode) mode:r,rb,r+,rb+,w,
f=open( ) str=f.read() f.close()
pickle模块实现了基本的数据序列和反序列化

import pickle

# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

File方法

open()方法:用于打开一个文件并返回文件对象，如果无法打开则抛出异常，使用完一定要调用close()

open(file,mode='r',encoding=None)
1

OS文件/目录

主要方法介绍：os模块

>>> import os
>>> os.getcwd()      # 返回当前的工作目录
'C:\\Python34'
>>> os.chdir('/server/accesslogs')   # 修改当前的工作目录
>>> os.system('mkdir today')   # 执行系统命令 mkdir 

1
2
3
4
5
6

错误和异常

异常捕获使用try/except语句

while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")
1
2
3
4
5
6

在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容(try/except…else)

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

1
2
3
4
5
6
7
8
9
10
11
12
13

触发异常使用raise

面向对象

类定义：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

1
2
3
4
5
6
7

类对象支持：属性引用和实例化 ，引用: obj.name
类的构造方法：创建类的时候自动调用

def __init__(self):
    self.data = []
    
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5
1
2
3
4
5
6
7
8
9

self代表类的实例 而非类，类的方法与普通函数只有一个区别，必须第一个参数是self

继承 ：（派生类）

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

例子：

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

多继承 需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

方法重写 重载类似
类的私有属性：两个下划线开头 声明为私有(属性和方法)
运算符重载与类的专有方法 : init del repr len cmp call add sub mul pow mod truediv

命名空间和作用域

内置名称 全局名称 局部名称 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

a = 10
def test():
    global a
    a = a + 1
    print(a)
test()
1
2
3
4
5
6

标准库

命令行参数

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']
1
2
3

高级教程

正则表达式

正则表达式是一个特殊的字符序列，能帮助检查字符串是否与模式匹配。re模块使其拥有全部的功能，compile函数根据一个模式字符串和可选标志参数生成一个正则表达式对象
简介 ：
实例 ¹+abc$
^为匹配输入字符串开始的位置；[0-9]+ 匹配多个数字，[0-9]匹配单个数字 。abc$匹配字母abc并以abc结尾，$为匹配输入字符串的结束位置。

可选标志（flags):

re.match(pattern,string,flags=0) 参数说明：1.匹配的正则表达式 2.要匹配的字符串 3.标识位 尝试从字符串起始位置匹配一个模式，如果不是起始位置匹配成功的话就返回none
可以使用group(num）或者groups()匹配对象函数来获取匹配表达式：group(num=0):

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配 输出 (0,3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配  输出 None
 
实例二:
import re
line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
# (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

re.search(pattern,string,flags=0) :扫描整个字符串并返回第一个成功的匹配。与match区别是match只匹配字符串的开始。

re.sub(pattern,repl,string,count=0,flags=0)

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
• flags : 编译时用的匹配模式，数字形式

关于更多关于正则表达式符号内容请参考：https://www.runoob.com/python3/python3-reg-expressions.html#flags

CGI编程

CGI:通用网关接口，运行在服务器上，因为过时不再进行讲解。（后续填坑）

Mysql

下载链接 推荐使用PyMySQL(后面安装方法)

pip install mysql-connector-python -i https://pypi.tuna.tsinghua.edu.cn/simple
1

连接数据库

import mysql.connector
 
mydb = mysql.connector.connect(
  host="localhost",
  user="root",
  passwd="123456",
  database="runoob_db"
)
mycursor = mydb.cursor()

1
2
3
4
5
6
7
8
9
10

插入数据

sql='insert into pythontest values(%s,%s)'
val=('123','mytest')
mycursor.execute(sql,val)
mydb.commit() #更新数据库必须要加的
print('suss')
1
2
3
4
5

查询数据

sql='select * from stud'
mycursor.execute(sql)
myresul=mycursor.fetchall() #获取所有记录
for x in myresul:
    print(x)
1
2
3
4
5

如果只要读取一条数据，可以使用fetchone()方法
其余的都是数据库基本功了。

删除数据

sql = "DELETE FROM sites WHERE name = 'stackoverflow'"
mycursor.execute(sql)
mycursor.execute(sql)
# 为了防止发生sql注入的攻击，可以使用%s占位符来转义删除语句的条件
sql = "DELETE FROM sites WHERE name = %s"
na = ("stackoverflow", )
mycursor.execute(sql, na)
1
2
3
4
5
6
7

可以使用PyMySQL进行数据库连接，PyMySQL 是在 Python3.x 版本中用于连接 MySQL 服务器的一个库

pip3 install PyMySQL -i https://pypi.tuna.tsinghua.edu.cn/simple
1

网络编程

两个级别的网络服务：1.低级别网络服务支持基本的Socket （套接字） 2.高级别的网络服务模块SocketServer 提供了服务器中心类

socket.socket([family[,type[,proto]]])

# family：套接字家族可以是AF_UNIX或者AF_INET
# type:面向连接还是非连接
# protocol:一般不填默认为0
1
2
3
4
5

Socket对象（内建）方法：

#服务端
import sys
import socket

server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host=socket.gethostname()
port=9999
server.bind((host,port))
server.listen(5)

while True:
    clients,add=server.accept()
    print('连接地址：%s'%str(add))
    msg='welcom'+'\r\n'
    clients.send(msg.encode('utf-8'))
    clients.close()
 

#客户端
import imp
import socket
import sys

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host=socket.gethostname()
port=9999
s.connect((host,port))
msg=s.recv(1024)
s.close()
print(msg.decode('utf-8'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

SMTP发送邮件

import smtplib
smtpo=smtplib.SMTP([host[,port[,local_host_name]]])

# host SMTP服务器主机
# port 一般情况下SMTP端口号为25
# local_hostname：如果SMTP在本机上只需要指定服务器为localhost即可

# 发送邮件
SMTP.sendmail(from_addr,to_addr,msg[,mail_options,rcpt_options])

1
2
3
4
5
6
7
8
9
10

一个完整的从qq邮箱发送的例子,注意邮箱要开启SMTP服务，密码是对应的授权码

import smtplib 
from email.mime.text import MIMEText
from email.header import Header
#引入smtplib、MIMETex和Header

mailhost='smtp.qq.com'
#把qq邮箱的服务器地址赋值到变量mailhost上，地址应为字符串格式
qqmail = smtplib.SMTP()
#实例化一个smtplib模块里的SMTP类的对象，这样就可以调用SMTP对象的方法和属性了
qqmail.connect(mailhost,587)
#连接服务器，第一个参数是服务器地址，第二个参数是SMTP端口号。
#以上，皆为连接服务器。

account = input('请输入你的邮箱：')
#获取邮箱账号，为字符串格式
password = input('请输入你的密码：')
#获取邮箱密码，为字符串格式
qqmail.login(account,password)
#登录邮箱，第一个参数为邮箱账号，第二个参数为邮箱密码
#以上，皆为登录邮箱。

receiver=input('请输入收件人的邮箱：')
#获取收件人的邮箱。

content=input('请输入邮件正文：')
#输入你的邮件正文，为字符串格式
message = MIMEText(content, 'plain', 'utf-8')
#实例化一个MIMEText邮件对象，该对象需要写进三个参数，分别是邮件正文，文本格式和编码
subject = input('请输入你的邮件主题：')
#输入你的邮件主题，为字符串格式
message['Subject'] = Header(subject, 'utf-8')
#在等号的右边是实例化了一个Header邮件头对象，该对象需要写入两个参数，分别是邮件主题和编码，然后赋值给等号左边的变量message['Subject']。
#以上，为填写主题和正文。

try:
    qqmail.sendmail(account, receiver, message.as_string())
    print ('邮件发送成功')
except:
    print ('邮件发送失败')
qqmail.quit()
#以上为发送邮件和退出邮箱。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# 协议  服务器         SSL   非 SSL
# SMTP smtp.163.com   465   25
# IMAP imap.163.com   993   143
# POP3 pop.163.com    995   110
# -------------------------------
# SMTP smtp.qq.com    465/587
# IMAP imap.qq.com    993
# POP3 pop.qq.com     995
# -------------------------------
# SMTP smtp.gmail.com 465(SSL)/587(TLS/STARTTLS)
# IMAP imap.gmail.com 993
# POP3 pop.gmail.com  995
# -------------------------------
# 163/qq: password 为授权码
# gmail: password 为邮箱密码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

多线程

线程分为：内核线程（操作系统） 用户线程
使用的模块：_thread threading (推荐)

_thread.start_new_thread(function,args[,kwargs])
# function -线程函数
# args -传递给线程函数的参数
# kwargs -可选参数
1
2
3
4

import _thread
import time

def print_time(threadName,delay):
    count=0
    while count<5:
        time.sleep(delay)
        count+=1
        print('%s:%s'%(threadName,time.ctime(time.time())))
        
# 2个线程
if __name__=='__main__':
    try:
        _thread.start_new_thread(print_time,('Thread-1',2,))
        _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
    except:
        print('Error')
    while 1:
        pass    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Thread类方法名类似于Java,下面写一个程序继承Thread类

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.delay, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

线程同步

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.delay, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

JSON数据解析

简单介绍JSON语法基本内容：(是JavaScript对象表示语法的子集)：数据在名称/值对中；数据由逗号分隔 ；大括号{}保存对象 ；中括号[]保存数组

-- 键值对
{ "name":"菜鸟教程" , "url":"www.runoob.com" }
-- 数组
{
    "sites": [
        { "name":"菜鸟教程" , "url":"www.runoob.com" }, 
        { "name":"google" , "url":"www.google.com" }, 
        { "name":"微博" , "url":"www.weibo.com" }
    ]
}

--使用JavaScript语法
var sites = [
    { "name":"runoob" , "url":"www.runoob.com" }, 
    { "name":"google" , "url":"www.google.com" }, 
    { "name":"微博" , "url":"www.weibo.com" }
];
sites[0].name -- 访问第一项数据 将返回runoob

-- JSON.parse(): 将一个 JSON 字符串转换为 JavaScript 对象。
-- JSON.stringify(): 于将 JavaScript 值转换为 JSON 字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用json模块对JSON数据进行编解码，包含2个函数： json.dumps() 编码 ；json,loads() 解码

实例演示了 Python 数据结构转换为JSON：

import json

data={
    'name':'run',
    'url':'www.baidu.com'
}

json_str=json.dumps(data)
print ( json_str)

#处理文件的程序
# 写入 JSON 数据
with open('data.json', 'w') as f:
    json.dump(data, f)
 
# 读取数据
with open('data.json', 'r') as f:
    data = json.load(f)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

日期和时间

每个时间戳都以自从 1970 年 1 月 1 日午夜（历元）经过了多长时间来表示。

import time  # 引入time模块

ticks = time.time()
print ("当前时间戳为:", ticks)
1
2
3
4

用一个元组装起来的9组数字处理时间
struct_time元组：属性tm_year tm_mon tm_mday tm_yday(一年第几天) tm_wday(0到6)

import time

localtime=time.localtime(time.time()) # 元组时间
localtime=time.asctime(time.localtime(time.time())) # 获取格式化的时间
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) # 格式化日期
# %y 两位数的年份  %Y 四位数的年份 %m 月份  %d 月内中的一天  %H 24小时数 
1
2
3
4
5
6

获取某月日历
Calendar模块

import calendar

cal = calendar.month(2016, 1)
print ("以下输出2016年1月份的日历:")
print (cal)  # 将输出日历
1
2
3
4
5

urllib

urllib库用于操作网页URL，并对网页的内容进行抓取处理。
urllib.request

urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)

# url:地址
# data 发送到服务器的其他数据对象 默认为None
# cafile :CA证书
# context：ssl.SSLContext类型
1
2
3
4
5
6

form urllib.request import urlopen

myurl=urlopen('www.baidu.com')
print(myurl.read())

# 使用read函数获取HTML实体代码
1
2
3
4
5
6

判断网页是否可以正常访问：
使用getcode()获取网页状态码，返回200正常，404就说明不存在

import urllib.request

myURL1 = urllib.request.urlopen("https://www.runoob.com/")
print(myURL1.getcode())   # 200

try:
    myURL2 = urllib.request.urlopen("https://www.runoob.com/no.html")
except urllib.error.HTTPError as e:
    if e.code == 404:
        print(404)   # 404
1
2
3
4
5
6
7
8
9
10

pip

pip是python包管理工具，提供了对包的查找、下载、安装、卸载的功能
注意python 2.7.9+或python 3.4+都自带了pip
pip 注意在cmd终端运行

pip --version #查看版本
pip install some_package # 下载包
pip uninstall some_package  #卸载
pip list # 查看已经安装的软件包
python3 -m pip install XXX # 如果python3 和python2同时有需要加上标注
1
2
3
4
5

pip 换源
一般使用普通的下载会很慢，原因在于服务器不再国内，需要加上镜像网站

pip install package -i https://pypi.tuna.tsinghua.edu.cn/simple # -i 清华大学
# https://pypi.mirrors.ustc.edu.cn/simple/ 中科大
# https://pypi.doubanio.com/simple/ 豆瓣
1
2
3

---

1. 0-9 ↩︎