从头学python之师姐扔给我30GB的数据让我整理

目录

Python 发展历史

1,基础语法：

2，变量类型

3,运算符

4，条件语句

5,循环语句

 6,函数

参数传递

可更改(mutable)与不可更改(immutable)对象

全局变量和局部变量

---

Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。

Python 由 Guido van Rossum 于 1989 年底发明，第一个公开发行版发行于 1991 年。

像 Perl 语言一样, Python 源代码同样遵循 GPL(GNU General Public License) 协议。

------度娘

Python 发展历史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。

环境准备：(我们主要搞python3) www.python.org 直接下载相对应平台的安装包

1,基础语法：

       

通过脚本参数调用解释器开始执行脚本，直到脚本执行完毕。当脚本执行完成后，解释器不再有效。

让我们写一个简单的 Python 脚本程序。所有 Python 文件将以 .py 为扩展名。将以下的源代码拷贝至 test.py 文件中。

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

print ("Hello, Python!")
#Hello, Python!

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
    # 没有严格缩进，在执行时会报错
  print ("False")

#这是多行注释
"""
Answer
True
"""

IndentationError: unindent does not match any outer indentation level错误表明，你使用的缩进方式不一致，有的是 tab 键缩进，有的是空格缩进，改为一致即可。建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用

2，变量类型

    

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号 = 用来给变量赋值。

等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
 
print counter
print miles
print name
#100
#1000.0
#John


#Python允许你同时为多个变量赋值。例如：
a = b = c = 1
#您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"

"""
Python支持四种不同的数字类型：

int（有符号整型）
long（长整型，也可以代表八进制和十六进制）
float（浮点型）
complex（复数）
"""
#数字数据类型用于存储数值
var1 = 1
var2 = 10

#字符串或串(String)是由数字、字母、下划线组成的一串字符。
s = "a1a2···an"   # n>=0
"""
python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
"""


"""

Python有五个标准的数据类型：

Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
"""


"""
List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
"""
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表


"""
Python 元组
元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
"""
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第四个（不包含）的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

#元组是不允许更新的，所以以上代码执行错误，结果如下：
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

"""
Python 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
"""
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值



"""
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
"""

3,运算符

4，条件语句

flag = False
name = 'luren'
if name == 'python':         # 判断变量是否为 python 
    flag = True              # 条件成立时设置标志为真
    print 'welcome boss'     # 并输出欢迎信息
else:
    print name               # 条件不成立时输出变量名称


"""
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

"""
num = 5     
if num == 3:            # 判断num的值
    print 'boss'        
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0:           # 值小于零时输出
    print 'error'
else:
    print 'roadman'     # 条件均不成立时输出

"""
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
"""
# 例3：if语句多个条件
 
num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print 'hello'
# 输出结果: hello
 
num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine
 
num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine

"""
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
"""

5,循环语句

  Python 提供了 for 循环和 while 循环（在 Python 中没有 do..while 循环）:

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1
 
print "Good bye!"


#continue,break;
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

 6,函数

     

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

  #"打印传入的字符串到标准显示设备上"
  def printme( str ):
     print str
     return
  
  
  
  """
  定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
  
  这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
  
  如下实例调用了printme（）函数：
  """
  # "打印任何传入的字符串"
  def printme( str ):
    
     print str
     return
   
  # 调用函数
  printme("我要调用用户自定义函数!")
  printme("再次调用同一函数")

  参数传递

  在 python 中，类型属于对象，变量是没有类型的：

• a=[1,2,3]     a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print b # 结果是 2


#"修改传入的列表"
def changeme( mylist ):
   mylist.append([1,2,3,4])
   print "函数内取值: ", mylist
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print "函数外取值: ", mylist
"""
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
"""

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

好了基础语法学的差不多了，我们开始解决问题：

我们明确下我们的目标，我们需要制作一个字典，字典师姐都已经写好了，

这里的值是就是我们需要的检索词。字典制作好之后，我们需要一行一行的去和我们检索的内容去匹配，我们有一百个表，每个表有250000行 ，每行检索的值平均都在15个左右，如此大的数据我们需要优化下我们检索的方式

from email import header
from ntpath import join
import numbers as nb
import string
from time import sleep, time
import pandas as pd
import xlrd as xl 
import xlwt as xw
import os
import time  as tm
from openpyxl import load_workbook
import numpy as np
from pandas import DataFrame
 
 
dfd=r'D:\date_test\dic'
fd=r'D:\date_test\\test1\data'
 
path="D:\date_test\dic\dic01.xlsx"
data=pd.read_excel(path, sheet_name=0, header=0, names=None, index_col=None)
 
 
 
"""
返回该目录下得所有文件地址
"""
def eachfile(filepath):
    musicfile=[]
    pathdir=os.listdir(filepath)
 
    for s in pathdir:
        newdir = os.path.join(filepath,s) # 将文件命加入到当前文件路径后面
        if os.path.isfile(newdir):        #如果是文件
                musicfile.append(newdir)
 
    return musicfile  
    
 
"""
生成我们需要的字典
"""
def get_dic(path):
    dic=[]
    pathdir=os.listdir(path)
    i=0
    t1=tm.time()
    print("字典生成中.......")
    for filename in pathdir:
        newdir = os.path.join(path,filename)
        print(newdir)
        data=pd.read_excel(newdir,sheet_name=0, header=0, names=None, index_col=None,engine='openpyxl')
        
        for dd in data.values:
            i=i+1
            dic.append(dd)
    print("生成字典字段个数:")
    print(i)
    t2=tm.time()
    print("字典生成时间"+str(t2-t1))
        
    return dic
 
"""
kmp算法：不用回溯
   时间：线性时间
"""

def pushu_kmp( st, m):
    if len(st)<len(m):
        return 0
    for i in range(len(st)):
        flag=0
        for j in range(len(m)):
            if (len(m)+i)>len(st):
                flag=1
                break
            if st[i+j]!=m[j]:
                flag=1
                break
        if flag==0:
            return 1
    return 0


def writetocsv(filename,filelist):

      name=['one','tmw']
      test=pd.DataFrame(columns=name,data=filelist)#数据有三列，列名分别为one,two,three
      test.to_csv("wukong"+str(filename)+'.csv',encoding='utf-8')
              
            
"""
测试我们朴素算法
"""            
#s="我们需要匹配 同时需要将符合要求写入我们的目标文烟火"
#t="烟火"
#print(pushu_kmp(s,t)) 
 
"""
我们需要匹配，同时需要将符合要求写入我们的目标文件夹
"""
 
pathdir=os.listdir(fd)
itme_table=0
anw=0
#取得字典
dic =get_dic(dfd)

for item1 in pathdir:
     newdir = os.path.join(fd,item1)
     print(item1)
     data=pd.read_csv(newdir)
     #我们从每个表格开始匹配我们的字典
     itme_col=0
     an=[]
     t1=tm.time()
     for dc in dic:
        print("匹配项："+dc)
        for dd in data.values:
            #字段处理，挑选匹配的选项，加入字典
            if(pushu_kmp(dd[1],dc)==1):
                an.append(dd)
                anw=anw+1
                if len(an)>10000:
                    print("生成中......")
                    writetocsv(20+itme_col+anw,an)
                    an.clear()
                    sleep(3)
            itme_col=(itme_col+1)
     itme_table=itme_table+1
     t2=tm.time()
     print(item1+" 检测完花费时间："+str(t1-t2))
     sleep(2)
     print("表："+str(itme_table)+"end....")
     print("clear.....")
     writetocsv(str(itme_table)+str(itme_col)+str(anw),an)
     an.clear() 

革命尚未完成，明天继续