python重点

2021-09-10 21:33:13 阅读：139 来源： 互联网

标签：dict1 结果 python list1 re print 重点运行

python中的变量命名只能以字母或下划线开头
数值int 字符串str 元组tuple 列表list 字典dict 集合set 布尔值True、False
占位符：
%d十进制整数
%i十进制整数
%f：浮点数
%%：字符%
%s：字符串
int(input('请输入您的考试成绩：'))
> == < 等比较运算符带有返回值
*乘法 **次方 /除法 //除法取整 %除法取余
sep参数代表多个值之间以什么进行连接、默认为空格
end参数
str1 = 'abcdefg'
print('ab' in str1) #运行结果为：True
print('ac' in str1) #运行结果为：False

str1='hello word'
print(str1.count('l',4)) #运行结果为：0
print(str1.count('l',0,3)) #运行结果为：1
print(str1.split('a')) #运行结果为['hello word']
print(str1.split('l')) #运行结果为['he', '', 'o word']
split默认以空格进行分割
split返回的是一个列表

str1='duoceoshio'
print(str1.rfind('o',0,9)) #运行结果为：5

find没找到元素就返回-1

str.strip( )默认删除空格

str.replace(old,new,次数)可以限制替换次数

str1='abcd'
list1=list(str1)
list1=['a','b','c','d']

列表可以相加：
list1=[1,2]
list2=[3,4]
list3=list1+list2=[1,2,3,4]

列表可以与整数相乘
list1=[1,2]
list2=list1*2
list2=[1,2,1,2]

append( )可以追加任何数据类型，整体追加
extend( )只能追加可迭代对象，而且会拆开

list1.insert(1,'a')
list1.remove('a')
del list1[4]
del list1
list1.pop( )默认删除最后一个元素
list1[0]='a'
list1.clear()
len(list1)
list1.index('f')
list1.reverse()
list1.sort( ) 默认升序，默认reverse=False sort( ) 只能用于列表排序
sorted(list1) 会返回一个列表，只用于可迭代对象

# str1 = '162759'
# list1 = sorted(str1)
# print(list1) #运行结果为：['1', '2', '5', '6', '7', '9']

# str2 = ''.join(list1)
# print(str2) #运行结果为：125679

Python join() 方法用于将序列中的元素（必须是str）以指定的字符连接生成一个新的字符串。

python中is是用于判断两个对象是否指向同一内存地址：
print(id(list1))
print(id(list2))
print(list1 is list2) #运行结果为：False

修改序列中的值后，内存地址变化的为不可变序列
修改序列中的值后，内存地址不变化的为可变序列

tuple(list1)
list(tuple1)

str1='abcd'
list1=list(str1)
tuple1=tuple(str1)
print(list1) ['a', 'b', 'c', 'd']
print(tuple1) ('a', 'b', 'c', 'd')

#1、python中的深浅拷贝
# 拷贝我们可以先理解为一个赋值的概念
#举例：①
# a = 1
# b = a
# print(a) #运行结果为：1
# print(b) #运行结果为：1
# print(id(a)) #运行结果为：140730443784848
# print(id(b)) #运行结果为：140730443784848

#举例：②
# a = [1,2,3]
# c = a
# a[0] = 'hellow'
# print(a) #运行结果为：['hellow', 2, 3]
# print(c) #运行结果为：['hellow', 2 , 3]
# print(id(a)) #运行结果为：2489402811016
# print(id(c)) #运行结果为：2489402811016

#举例：③
import copy #导入copy这个模块
#第一步操作如下：
# a = [1,2,3]
# b = copy.copy(a)
# print(a) #运行结果为：[1, 2, 3]
# print(b) #运行结果为：[1, 2, 3]
# print(id(a)) #运行结果为：1530612734536
# print(id(b)) #运行结果为：1530611558216
#第一步备注如下:

# 1、copy.copy()这个方法是浅拷贝
#2、通过打印结果可以看到当b的值是通过浅拷贝a的值时候，a和b的存储地址不一样
#3、可以理解为a的值在内存中有一块存储地址，b通过浅拷贝a的值后会在内存新开辟一块内存地址

#第二步操作如下：
# a = [1,2,3]
# b = copy.copy(a)
# a[0] = 'hellow'
# print(a) #运行结果为：['hellow', 2, 3]
# print(b) #运行结果为:[1, 2, 3]
# print(id(a)) #运行结果为：2257773640520
# print(id(b)) #运行结果为：2257773520840
# 第二步备注如下：
# 1、通过索引修改a里面的某个元素的值，查看a的结果发现已经发生改变
# 2、通过索引修改a里面的某个元素的值，查看b的结果发现无任何改变
# 3、由于当b通过浅拷贝a后值存储的地址和a存储的地址不是同一地址，所
# 以a和b任何一方修改里面元素的值都不会影响对方，可以理解为两个人已经
# 离婚了，没有任何瓜葛。

# 举例：④
# a = [[1,2,3],[4,5,6]]
# b = copy.copy(a)
# print(a) #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(a)) #运行结果为：2559396978312
# print(b) #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(b)) #运行结果：2559397186504
# a[0][0] = 'hellow'
# print(a) #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# print(b) #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# ④备注如下：
# 1、当列表里面包含列表的时候用copy.copy()浅拷贝这个方法有特殊情况
# 2、相当于b整体开辟了一个新的内存地址，但是b里面的列表内存地址还是
# 引用a里面的列表内存地址，所以当a修改a里面列表元素的值时候，b也会
# 发生改变，因为b里面的列表和a里面的列表指定同一块内存地址。可以理
#解为两个人离婚了，由于还有孩子，所以还藕断丝连

# 举例：⑤
# a = [[1,2,3],[4,5,6]]
# b = copy.deepcopy(a)
# print(a) #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(a)) #运行结果为：2559396978312
# print(b) #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(b)) #运行结果：2559397186504
# a[0][0] = 'hellow'
# print(a) #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# print(b) #运行结果为:[[1, 2, 3], [4, 5, 6]]
# ⑤备注如下：
# 1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。可以理解为：两个人已经离婚了，由于没有孩子，所以没有任何瓜葛了。

'元组支持索引、切片'
# tuple1 = (1,2,3,4)
# print(tuple1[0]) #运行结果为：1
# print(tuple1[0:2]) #运行结果为：(1, 2)

'元组支持与元组相加'
# tuple1 = (1,2)
# tuple2 = (3,4)
# print(tuple1+tuple2) #运行结果为：(1, 2, 3, 4)

'元组支持与整数相乘'
# tuple1 = (1,2)
# print(tuple1*2) #运行结果为：(1, 2, 1, 2)

# list1 = [('广东','深圳'),('湖南','长沙'),('江西','景德镇')]
# dict1 = dict(list1)
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇'}
# print(type(dict1)) #运行结果为：<class 'dict'>

# dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇'}
# dict1['广东'] = '广州'
# print(dict1) #{'广东': '广州', '湖南': '长沙', '江西': '景德镇'}
'备注：添加一个键值对，如果键存在则更新最新的值'

# dict1['湖北'] = '武汉'
# print(dict1) #{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': '武汉'}
'备注：添加一个键值对，如果键不存在则直接添加'

'字典常见的操作之keys方法：取出所有的键'
# print(dict1.keys()) #运行结果为：dict_keys(['广东', '湖南', '江西'])

'字典常见的操作之values方法：取出所有的值'
# print(dict1.values()) #运行结果为：dict_values(['深圳', '长沙', '景德镇'])

'根据键取值'
# print(dict1['广东']) #运行结果为：深圳

'字典常用的函数之setdefault()'
# dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇'}
# dict1.setdefault('广东','广州')
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇'}

# dict1.setdefault('湖北','武汉')
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': '武汉'}

# dict1.setdefault('湖北')
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': None}
'''
setdefault注意点：
1、使用setdefault添加一个键值对，如果键存在，则添加失败
2、使用setdefault添加一个键值对，如果键不存在，则添加该键值对到末尾
3、使用setdefault添加一个键时，可以添加成功且键对应的值为None

'字典里面的键值是唯一的，值可以重复'
# dict1 = {'广东':'深圳','湖南':'深圳','江西':'景德镇'}
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '深圳', '江西': '景德镇'}
'备注：字典中的值可以重复'

dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇','广东':'广州'}
print(dict1) #运行结果为：{'广东': '广州', '湖南': '长沙', '江西': '景德镇'}
'备注：字典中的键是唯一的'

seq = ('Google', 'Runoob', 'Taobao')
dict1={ }
dict1 = dict1.fromkeys(seq)
{'Google': None, 'Taobao': None, 'Runoob': None}
dict1=dict1.fromkeys(seq, 10)
{'Google': 10, 'Taobao': 10, 'Runoob': 10}
fromkeys 方法只返回值

dict1=dict.fromkeys(list1)
print(dict1)
{'Google': None, 'Taobao': None, 'Runoob': None}

'给你一个列表如何进行去重'
'第一种去重的方法===通过转换成字典'
# list1 = ['a','b','c','a','b','c']
# dict1 = dict.fromkeys(list1)
# print(dict1) #运行结果为：{'a': None, 'b': None, 'c': None}
# list1 = list(dict1)
# print(list1) #运行结果为：['a', 'b', 'c']

'第二种去重的方法===通过遍历'
# list1 = ['a','b','c','a','b','c']
# list2 = []
# for i in list1:
# if i not in list2:
# list2.append(i)
# else:
# pass
# print(list2) #运行结果为：['a', 'b', 'c']

'去重的第三种方法==通过转换成集合'
list1 = ['a','b','c','a','b','c']
set1 = set(list1)
print(set1) #运行结果为：{'a', 'c', 'b'}

list1=[1,'a',[1,2]]
print(list[2][0])

if条件判断语句中的三目运算
x = int(input("请输入第一个数"))
y = int(input("请输入第二个数"))

if x>y:
print(x)
else:
print(y)

print(x) if x>y else print(y)

if的嵌套语句（if中包含if）

用while循环求出1-100之间的和
i = 1
sum = 0
while i<=100:
sum+=i
i+=1
print(sum)
运行结果为：5050

用while循环求出1-100之间的偶数之和
i = 0
sum = 0
while i<=100:
sum+=i
i+=2
print(sum)
运行结果为：2550

用while循环求出1-100之间的奇数之和
i = 1
sum = 0
while i<=100:
sum+=i
i+=2
print(sum)
运行结果为：2500

for i in range(5):
print(i)
运行结果为：
0
1
2
3
4

for i in range(10):
print(i,end=' ')
运行结果为：0 1 2 3 4 5 6 7 8 9

整型是不能被遍历的，因为整型是不可被迭代的对象

for i in range(10):
if i == 6:
continue
print(i,end=' ')
运行结果为：0 1 2 3 4 5 7 8 9

for i in range(10):
if i == 5:
break
print(i,end=' ')
运行结果为：0 1 2 3 4

a = 10
while a>0:
print('当前变量值为%d'%(a))
a = a-1
if a == 5:
break

def func1(*x):
print(x)
func1(1)
(1,)

# def func1(**dict1):
# print(dict1) #运行结果为：{'广东': '深圳', '湖南': '长沙'}
#
# func1(广东='深圳',湖南='长沙')

def func1(name,*tuple1,where='北京',**dict1):
print(name)
print(tuple1)
print(where)
print(dict1)

func1('张三',1,2,3,where='上海',广东='深圳',湖南='长沙')

global num #声明全局变量
num = 200

# name = '张三'
# where = '多测师'
# print('{0}来{1}学测试'.format(name,where))
#运行结果为：张三来多测师学测试

# list1 = ['张三','李四','王五']
# list2 = ['多测师龙华校区','多测师宝安校区']
# print('{}去{}学测试'.format(list1,list2))
#['张三', '李四', '王五']去['多测师龙华校区', '多测师宝安校区']学测试

# list1 = ['张三','李四','王五']
# list2 = ['多测师龙华校区','多测师宝安校区']
# print('{0[2]}去{1[0]}学测试'.format(list1,list2))
# 运行结果为：王五去多测师龙华校区学测试

dict1 = {'广东':'深圳','湖南':'长沙'}
print('张三去{0[广东]}挣大钱'.format(dict1))
#运行结果为：张三去深圳挣大钱

file1 = open(r'C:\Users\Administrator\Desktop\test.txt','r',encoding='utf8')
r用来防止转义
value1 = file1.read()
print(value1)

# value1 = file1.readlines() #获取文件中的所有内容且返回的是列表
# print(value1)

# value1 = file1.readline() #获取文件中首行内容且返回的是字符串
# print(value1)

写的模式：w(写入覆盖)
o=open(r"C:\\aa.txt",'w');
o.write("hello duoceshi")
o.writelines("hello duoceshi")
o.close()

追加的模式：a(写入追加)
o.write("hello duoceshi")
o.writelines("hello duoceshi")
o.close()

file.write(str)的参数是一个字符串,就是你要写入文件的内容.
file.writelines(sequence)的参数是序列,比如列表,它会迭代帮你写入文件。

with open(r"C:\\aa.txt", 'r')as f:
a = f.read()
b = f.readline()
c = f.readlines()
d = f.write()
e = f.writelines()
用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常。

1 write()需要传入一个字符串做为参数,否则会报错

2 writelines()既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件

注意：writelines必须传入的是字符序列,不能是数字序列
如：list_1023 = [1,2,3,4,5]

报错:TypeError: write() argument must be str, not list

import os
list1=['1','2','3']
tuple1=('4','5','6')
str='abc'
f=open(r'C:\Users\Administrator\Desktop\dcs65.txt','w')
f.writelines(tuple1)

def __init__(self,i):
@classmethod
@staticmethod

1、子类继承父类后可调用父类的所有方法
2、子类继承父类后，父类无法调用子类的方法
3、当子类和父类同时拥有构造函数函数时，默认使用子类自己的构造函数
4、当子类没有构造函数时，父类拥有构造函数，子类默认继承父类的构造函数
5、当子类同时继承多个父类时，优先使用自己的构造函数，如果子类没有构造函数则继承父类的构造函数
6、当子类同时继承多个父类时，优先继承第一个父类的构造函数，如果第一个父类没有构造函数，则继承第二个父类
7、子类同时继承多个父类时，可以调用多个父类的方法
8、当父类继承其他类时，子类可以调用父类和父类继承的类方法

import pymysql
# db = pymysql.Connection(
# host='192.168.40.130',
# database='dcs65',
# user='root',
# password='123456',
# port=3306
# )
# r=db.cursor()
#
# sql='show tables'
# r.execute(sql)
# value1=r.fetchone()
# value=r.fetchmany(size=1)
# print(value)
# print(value1)

class Sql():
def __init__(self,host,database,user,password,port):
db = pymysql.Connection(
self.host=host,
self.database=database,
self.user=user,
self.password=password,
self.port=port
)
r = db.cursor()
self.r=r
def select_one(self,sql):
self.r.execute(sql)
value1 = self.r.fetchone()
value2 = self.r.fetchall()
print(value1)
print(value2)

s=Sql('192.168.40.130','dcs65','root','123456',3306)
s.select_one('show tables')

导入模块方法：
1.from dcs65 import lesson1
2.from dcs65.lesson1 import *
3.from dcs65.lesson1 import num,func1
4.from dcs65 import lesson1,lesson2
5.from dcs65 import lesson1 as ls #用于模块名太长
6.import time

'python中的time模块'
import time
# print(time.time()) #运行结果为：1630979264.3982198
# print(time.ctime()) #运行结果为：Tue Sep 7 09:48:41 2021
# print(time.asctime()) #运行结果为：Tue Sep 7 09:49:41 2021
# print(time.strftime('%Y-%m-%d-%H-%M-%S')) #运行结果为：2021-09-07-09-51-26
# print(time.strftime('%H-%M-%S')) #运行结果为：09-52-13
# time.sleep(5)

'python中的random模块'
import random
'生成0-1之间的浮点数'
# print(random.random()) #运行结果为：0.1356199110326416
'该方法生成指定范围内整数，包括开始和结束值'
# print(random.randint(1,10)) #运行结果为：8
'生成指定范围内的奇数，不包括结束值'
# print(random.randrange(1,11,2)) #运行结果为：1
'生成指定范围内的偶数，不包括结束值'
# print(random.randrange(0,11,2)) #运行结果为：0

'从序列seq中选择n个随机且独立的元素'
# str1 = 'abcdefg'
# tuple1 = (1,2,3,4,5,6)
# list1 = [1,2,3,4,5,6]
# set1 = {1,2,3,4,5,6}
# dict1 = {'a':1,'b':2,'c':3,'d':4}
# print(random.sample(str1,2)) #运行结果为：['c', 'd']
# print(random.sample(tuple1,2)) #运行结果为：[1, 5]
# print(random.sample(list1,2)) #运行结果为：[2, 4]
# print(random.sample(set1,2)) #运行结果为：[2, 5]
# list1 = []
# for i in dict1:
# value = dict1[i]
# list1.append(value)
# print(random.sample(list1,2)) #运行结果为：[3, 4]

'从序列中随机选取1个元素'
# list1 = [1,2,3,4,5]
# print(random.choice(list1)) #运行结果：1
# print(type(random.choice(list1)))#运行结果为：<class 'int'>
# print(random.choices(list1)) #运行结果为：[1]

'洗牌==只适用于列表，不支持其他序列'
# list1 = [1,2,3,4,5,6,7,8]
# random.shuffle(list1)
# print(list1) #运行结果为：[6, 1, 3, 7, 5, 4, 2, 8]

'MD5加密'
import hashlib #导入hashlib库
# h = hashlib.md5() #调用hashlib中md5方法生成一个md5对象
# h.update(b'zhangsan') #对象调用update方法将参数转换成哈希数据，参数只接受bytes类型，所以需要在参数前加b
# print(h.hexdigest()) #运行结果为：01d7f40760960e7bd9443513f22ab9af

# h = hashlib.md5() #调用hashlib中md5方法生成一个md5对象
# h.update('你好'.encode('utf-8')) #对象调用update方法将参数转换成哈希数据，参数只接受bytes类型，所以需要在参数前加b
# print(h.hexdigest()) #运行结果为：7eca689f0d3389d9dea66ae112e5cfd7

递归指的是：在函数内部调用函数本身

'python中的os模块'
import os
'获取当前执行命令所在目录的绝对路径'
os.getcwd()获取当前执行命令所在目录
os.path.isfile()判断是否文件
os.path.isdir() #判断是否是目录
os.path.exists() #判断文件或目录是否存在
os.listdir(dirname) #列出指定目录下的目录或文件 #返回的是列表
os.path.split(name) #分割文件名与目录 #返回的是元组
os.path.join(path,name) #连接目录与文件名或目录
os.mkdir(dir) #创建一个目录
os.rename(old,new) #更改目录名称

import re #导入正则模块
# r = re.match('\d','12dsahjks21321') #1
# r = re.match('\d','a12dsahjks21321')#报错
# r = re.match('\d+','1223dsahjks21321')#1223
# r = re.match('\d+','a1223dsahjks21321')#报错
# r = re.match('\d*','a1223dsahjks21321')#为空
# r = re.match('\d*','1223dsahjks21321') #1223
# r = re.match('\d?','1223dsahjks21321') #1
# r = re.match('\d?','a1223dsahjks21321') #为空
# r = re.match('\d{3}','1223dsahjks21321') #122
# r = re.match('\d{1,3}','1223dsahjks21321')#122
# r = re.match('\d{3,5}','1223dsahjks21321') #1223
# r = re.match('\d{5,6}','1223dsahjks21321') #报错
# r = re.match('^\d','1223dsahjks21321') #1
# r = re.match('^1[0-9][0-9]\d{8}$','18389581558') #18389581558
# r = re.match('^1223[a-z]{7}\d{5}$','1223dsahjks21321') #1223dsahjks21321
# r = re.match('^158[a-c]{3}\d{8}$','158abc89581559') #158abc89581559

print(r.group())
/
'''
\d:数字0-9
\D:非数字
\s:空白字符
\n:换行符
\r:回车符'

'''
'''
符号^：表示的匹配字符以什么开头
符号$：表示的匹配字符以什么结尾
符号*：匹配*前面的字符0次或n次
eg：ab* 能匹配a 匹配ab 匹配abb
符号+：匹配+前面的字符1次或n次
符号?：匹配?前面的字符0次或1次
符号{m}：匹配前一个字符m次
符号{m,n}：匹配前一个字符m到n次(包括n次)，m或n可以省略，mn都是正整数
'''
'''
1、match
从第一个字符开始匹配，如果第一个字符不是要匹配的类型、则匹配失败并报错
注意：如果规则带了'+'
，则匹配1次或者多次，无'+'只匹配一次
2、search
从第一个字符开始查找、一找到就返回第一个字符串，找到就不往下找，找不到则报错
3、findall
从第一个字符开始查找，找到全部相关匹配为止，找不到返回一个列表[]
4、compile
编译模式生成对象，找到全部相关匹配为止，找不到返回一个列表[]
'''
import re #导入正则模块
'match'
# r = re.match('\d','12dsahjks21321') #1
# r = re.match('\d','a12dsahjks21321')#报错
# r = re.match('\d+','1223dsahjks21321')#1223
# r = re.match('\d+','a1223dsahjks21321')#报错
# r = re.match('\d*','a1223dsahjks21321')#为空
# r = re.match('\d*','1223dsahjks21321') #1223
# r = re.match('\d?','1223dsahjks21321') #1
# r = re.match('\d?','a1223dsahjks21321') #为空
# r = re.match('\d{3}','1223dsahjks21321') #122
# r = re.match('\d{1,3}','1223dsahjks21321')#122
# r = re.match('\d{3,5}','1223dsahjks21321') #1223
# r = re.match('\d{5,6}','1223dsahjks21321') #报错
# r = re.match('^\d','1223dsahjks21321') #1
# r = re.match('^1[0-9][0-9]\d{8}$','18389581558') #18389581558
# r = re.match('^1223[a-z]{7}\d{5}$','1223dsahjks21321') #1223dsahjks21321
# r = re.match('^158[a-c]{3}\d{8}$','158abc89581559') #158abc89581559
# print(r.group())

'search'
# r = re.search('\d','a321dsa432') #3
# r = re.search('\d+','a321dsa432') #321
# r = re.search('\d*','a321dsa432') #为空
# r = re.search('\d?','a321dsa432') #为空
# r = re.search('\d{4}','a321dsa432') #报错
# r = re.search('\d{3,4}','a321dsa432') #321
# r = re.search('\d{4}','a3211dsa432') #3211
# print(r.group())

'findall'
# list1 = re.findall('\d','a121dsag321dsah1') #运行结果为：['1', '2', '1', '3', '2', '1', '1']
# list1 = re.findall('dcs(.+)dcs','dcs1234567dcs')#['1234567']
# list1 = re.findall('error:(.+)','dsaghjerror:dsahjdsahj') #['dsahjdsahj']
# print(list1)

# r = re.compile('dcs(.+)dcs')
# list1 = r.findall('dcs1234567dcs')
# print(list1) #运行结果为：['1234567']

标签：dict1,结果,python,list1,re,print,重点,运行
来源： https://blog.csdn.net/csdnlhd66/article/details/120230038

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

python重点