Python3初步实践教程概要

最新推荐文章于 2024-10-16 17:48:16 发布

三金C_C

最新推荐文章于 2024-10-16 17:48:16 发布

阅读量242

点赞数 3

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/QAZJOU/article/details/125617438

版权

Python 专栏收录该内容

12 篇文章 14 订阅

订阅专栏

“人生苦短，快学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)

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

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

数据类型转换

函数	描述
str(x)	将对象x转换为字符串
tuple(),set(),dict(),llist()	转换成对应类型
chr(x)	将一个整数变成字符
ord(x)	将一个字符转换为整数值
hex(x)	将一个整数转换为16进制
ord(x)	将一个整数转换为八进制

推导式

推导式是独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体，支持各种数据结构的推导式：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']

字典推导式

{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}

集合推导式

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

运算符

逻辑运算符 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 中")

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

数字Number

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

函数	描述
choice(seq)	从序列的元素随机挑选一个数
uniform(x,y)	范围[x,y]
random()	随机生成一个实数，在[0,1)范围
seed([x])	改变种子

字符串

单字符作为字符串，使用[]截取字符串，格式变量 [头下标：尾下标]
以字符串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))

内置函数

方法	描述
capitalize()	将第一个字符转换为大写
count(str,begin=0,end=len(string))	返回str在string出现的次数
find(str,beg=0,end=len(string))	检测str是否在字符串中
replace(old,new[,max])	将old替换成new
split(str=“”,num=string.count(str))	以str为分隔符

列表

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

方法	描述
list.append(obj)	末尾添加新的对象
list.count(obj)	统计某个元素在列表出现的次数
list.index(obj)	找出某个值的索引位置
list.sort(key=Nooe,reverse=False)

元组

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

字典

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

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)

集合

可以使用大括号或者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))

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

函数

def max(a,b):
    return a
def 函数名（参数列表）:
    函数体
 
if __name__=="__main__":

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

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

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

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

数据结构

列表

方法	描述
list.append(x)	添加到列表的结尾
list.insert(i,x)	在指定位置插入元素
list.remove(x)	删除值为x的第一个元素
list.pop([i])	从列表的指定位置删除元素
list.count(x)	计数
list.sort()	排序

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

遍历技巧

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

模块

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

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

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

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

输入和输出

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

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

读取键盘输入
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()

File方法

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

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

OS文件/目录

主要方法介绍：os模块

方法	描述
os.chdir(path)	改变当前工作目录
os.dup(fd)	复制文件描述符
os.getcwd()	返回当前工作目录
os.open(file,flags,[,mode])	打开一个文件
os.read(fd,n)	从文件描述符fd读取最多n个字节

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

错误和异常

异常捕获使用try/except语句

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

在 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('这句话，无论异常是否发生都会执行。')

触发异常使用raise

面向对象

类定义：

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

类对象支持：属性引用和实例化，引用: 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

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

继承：（派生类）

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

例子：

#类定义
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()

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

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

方法重写 重载类似
类的私有属性：两个下划线开头声明为私有(属性和方法)
运算符重载与类的专有方法 : 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()

标准库

命令行参数

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

高级教程

正则表达式

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

可选标志（flags):

修饰符	描述
re.l	使匹配对大小不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配
re.S	使匹配包括换行在内的所有字符
re.U	根据Unicode 解析字符
re.X	给予灵活的格式

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!!")

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

连接数据库

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

插入数据

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

查询数据

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

如果只要读取一条数据，可以使用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)

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

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

网络编程

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

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

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

Socket对象（内建）方法：

函数	描述
服务器端套接字
s.bind()	绑定地址（host,port）
s.listen()	开始TCP监听
s.accept()	被动接受TCP客户端连接
客户端套接字
s.connect()	主动初始化TCP服务器连接
s.close()	关闭套接字

#服务端
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'))

协议	功能用处	端口号	Python 模块
HTTP	网页访问	80	httplib, urllib, xmlrpclib
NNTP	阅读和张贴新闻文章，俗称为"帖子"	119	nntplib
FTP	文件传输	20	ftplib, urllib
SMTP	发送邮件	25	smtplib
POP3	接收邮件	110	poplib
IMAP4	获取邮件	143	imaplib
Telnet	命令行	23	telnetlib
Gopher	信息查找	70	gopherlib, urllib

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

一个完整的从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()
#以上为发送邮件和退出邮箱。

# 协议  服务器         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 为邮箱密码

多线程

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

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

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

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 ("退出主线程")

线程同步

使用 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 ("退出主线程")

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 字符串。

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

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int- & float-derived Enums	number
True	true
False	false
None	null

实例演示了 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)

日期和时间

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

import time  # 引入time模块

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

用一个元组装起来的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小时数

获取某月日历
Calendar模块

import calendar

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

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类型

form urllib.request import urlopen

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

# 使用read函数获取HTML实体代码

判断网页是否可以正常访问：
使用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

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同时有需要加上标注

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/ 豆瓣