一晃两个月了，好长时间不写了。有太多的借口去推脱，但静下来却也发觉，每个推脱都显的苍白。
今天写python，为什么选择py。因为python属于编程语言，而且也是开源的，在人工智能以后的发展上，目前来看也就py最契合。
好吧，我承认py是我比较喜欢的语言。简单，可读性强，一目了然。
这段时间一直在学习py。也真是觉得py在清洗数据方面有太多的好处，但还是要说精一到两门最好。数据分析更主要的是思维和算法。其它便是工具。
勿忘初心，方得始终，持之以恒，披荆斩棘。
以下是简单的入门python代码
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 31 14:53:43 2017
@author: Administrator
"""
#Python保留关键字
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else if or yield
assert else import pass
break except in raise
#关键字到此结束,运算符
+ - * /(浮点数除法) //(整数除法) 7//2 结果3
%(求余) **（幂） 3**4 结果81
divmod(9,2) 结果 (4,1)
int float 整形，浮点数。float 可以对字符串进行转化而int则不OK！
int('69.5')#带引号便为字符串。不可使用 int(69.5) is ok
#python 字符串不可以更改，但这里有一个小技巧就是三个单引号串起来字符串时，三引号的字符串内的
#数据的格式是不会 改变的，例如空格之类的。
#下列建立空字符串的意义就是对其转化赋值。
bottles=99
base=''
base+='this is '
base+=str(bottles)
base
print(base) # print输出会把单引号给省略。
str() 代表字符串的转化。
#转义字符 '\' 其中 '\n' 代表换行，\t 代表 对齐文本。\',\" 代表单，双引号。
# 输入\\意义代表输出一个\字符。
利用+ 号进行字符串或者字符串变量拼接，亦或直接链接。
'my world' 'this is cool' #输出时，并不添加空格
a='duck'
b=a
c='grey duck'
a+b+c
print(a,b,c)#对上述数据进行佐证。
#利用* 进行复制字符串，和乘的概念一样。
satrt='na '*4+'\n'
middle='Hey'*3+'\n'
end='goodbye.'
print(satrt,middle,end)
#这里的意义便是复制字符串
#利用[]偏移量进行字符串的提取。右边从0开始，左边从-1开始，接着便是-2，-3。这里你可以看出0是唯一的。
#这里利用的便是位置索引。
name='henny'
name.replace('h','p') #利用的便是replace函数后一个替换前一个。
print(name) #结果仍然为henny。说明字符串时不可改变的，但是可以用函数进行“临时性”改变。
'P'+name[1:] #本处使用的是切片 利用P和数据偏移量之后的字符进行串联。
#切片指的是[satrt:end:step] 他的意义便是：从何处开始，到何处结束，步长为多少的概念。
#[:] 提取从开头到结尾的整个字符串。
#[start:] 从start提取到结尾
#[:end]从开头提取到end-1
#[start:end]从start提取到end-1
#[start:end:step]从start提取到end-1，每step个字符
letters='15245'
len(letters) #len()属于内置函数 广义函数。
totals='this is somethiing,cool,toal,cool,'
totals.split(',') #split函数代表的是分割符，适用用字符串函数。加上（）就是字符串函数的调用。
#与split（）函数相反，join函数是合并函数
testjoin=['yeti','bigfoot','loch ness monster']
test2='\n'.join(testjoin)
print(test2) # 输出函数，是什么样子，输出什么样子
#在字符串中，空格也算一个偏移量。
libai='''床前明月光
疑是地上霜
举头望明月
step head eat banana'''
libai[:32]
len(libai)
libai.startswith('前')#判定是否打头
libai.endswith('na')#判定是否打尾，根据最后一个字符依次往前推
baili='step head eat banana'
libai.find(baili)
libai.find('s') #字符串偏移量是根据组合的头个字符出现的位置来进行判定。rfind则与find
#相反，是最后一次出现的位置。
libai.count('step') #统计出现的次数
ba='abcdefg1021,5'
ba.isalnum() #对数据进行字符亦或数字判定，如果出现汉子亦或标点符号，则返回false
#strip（）函数去除某种字符串的标点符号。
setup='a duck Goes \n into a bar.....'
print(setup)
setup.strip('\n')
setup.capitalize()#首字母变大
setup.title()#所有单词的首字母变大。
setup.upper()#所有字母都变大。
setup.lower()#所有字母变成小写
setup.swapcase()#所有大小写字符转换
setup.center(50) #在50个字符串中居中。
setup.ljust(50)#在50个字符串中左对齐left
setup.rjust(50)#50个字符串中右对齐right，其中更多的字符串类型%和format()
setup.replace('duck','lucky',2)#replace 函数有三个参数，第一个替换后的字符串，第二个被替换的字符串，第三个更改几处
#如果不填写，默认1处。
#元组，列表，字符串。元组不可改变，而列表则是可变的。
empty_list=[]
another_empty_list=list()
first_name=['hello','world','2587','this','this']#列表内是可以允许重复字符的。
abck='cattle'
list(abck)#转换成列表样式。加''标识字符串，不加标识名字内容，元组也可以转换成列表形式。
print(abck)
birthday='1/6/1952'
birthday.split('/')#利用该split转换成列表形式。
#列表和字符串一样，都可以通过统计偏移量，进行定位选择【offset】函数。列表最好的便是可以修改，而字符串和元组则不可以
#所以在使用的过程中，可以对字符串，元组进行列表的转换新赋值，而后进行修改。同时需要注意的是set()集合函数，会去掉重复的
#数值。同时列表同字符串一样，可以使用切片提取元素。test[::-1]得出列表的逆序。
first_name.append('zepoo') #最后添加一个元素
first_name
marxes=['one','two','three']
dayy=['four','five']
marxes.extend(dayy)# 使用extend添加合并列表
marxes
mon=['six','seven']
marxes+=mon #使用+=函数和extend函数并无明显差别都是和并函数。
marxes#其中append添加元素，他如果天剑的是一个列表，则会在列表中以元素显示，就是列表的列表。
#del属于python语句，其并不是函数，故而言之不可调用即 marxes[2].del
del marxes[2]#这个是正确的用法。所以要区分好函数调用和语句的区别。
marxes.append('one')
print(marxes)
marxes.remove('one') #删除某个指定的元素,经测试只能删除第一个，如果遇到多个元素该如何删除是需要思考的地方
print(marxes)
marxes.pop()#pop()和pop(-1)等同。即删除元素的最后一个值。其中pop()里面使用的是数字，定义为根据偏移量删除元素。
#这里需要注意的是pop(0)和pop()是不对等的。这点 需要注意，而且这里的用法也有很多。
marxes.insert(3,'heloo') #在指定位置插入数据。
marxes.index('heloo')#这个函数面对的主要是列表和find函数有所不同。
'heloo' in marxes #利用 in 判定列表值是否存在于函数内。
marxes.count('one')#同字符穿一样.count函数统计出现次数。
','.join(marxes)#join作为一个字符串参数，如果其加的是列表，则会转化为字符串。属于字符串方法
sorted_mar=sorted(marxes)
sorted_mar
marxes.sort()
marxes # sort 对原数据进行排序，而sorted则是对副本进行排序
shuzi=['1','2','3','4','10','2','7','5']#加‘’即为字符串函数，否则则为数字哦
txt=sorted(shuzi)#sorted()通用函数
txt
shuzi.sort()#sort()则为列表方法，reverse=true 表示降序排列
shuzi
test=[10,2,9,88,45,11,36,24,2]
sorted(test,reverse=True)#对副本进行降序排列
test.sort(reverse=True)#直接调用sort列表方法进行排序
len(marxes)# 返回列表长度列表方法和函数之间的额差异。
#在此需要注意的是，列表是可以改变的，而且指向的只是对象，标签，一个修改了，则所有的额同时可以修改。
#而对函数进行复制则有三种方法。一种是copy()函数，一种是list（）转换函数，以及切片
a=[1,2,3]
b=a.copy()
c=list(a)
d=a[:]
a
b
c
d
marx_tuple=('Groucho','chico','Harpo')
one,two,three=marx_tuple #这一个过程称为元组解包。
one;
two;
three; #元组如果是一个的话后边需要加',',否则就需要
password='swordfish',
icecream='tuttifrutti',
password,icecream=icecream,password
password
icecream #利用元组在一条语句中对多个变量的值进行交换，而不需要借助临时变量,这里利用的是重新赋值的意思。
abc='this is sothing'
abc='this is '
#字典dict，建立空键值对(key:value)
empty_dict={}
empty_dict
#使用dict()，对字典进行转化。
lol=[['a','b'],['c','d'],['e','f']]#双值列表数据。
dict(lol)
#包含双值列表的元组
tol=[('a',0),('b',2),('c',3)]
dict(tol)
#包含双字符的字符串组成的列表
los=['ab','cd','ef']
loss=dict(los) #使用zip函数可以简单的创建双元素序列。
loss
loss['c']=100 #对字典的键值进行替换，这里需要知道字典的键是唯一的。
loss
#使用update()合并字典
ab.update(cd) #利用cd字典合并到函数ab字典，如果有重复的键，那么则cd值覆盖ab值。
del loss[a]
#意义即和删除列表一样，这里字典主要是键。
#使用重新赋值 或者clear()
#对元组进行清洗
loss.clear()
loss={}
'c' in loss #同列表一样，in一样用于元组。
loss['c'] #使用字典根据键抽出‘值’
loss.get('c') #获取某个键的值
list(loss.keys()) #利用keys获取键然后转成列表形式。
list(loss.values())#使用values获取所有的值
list(loss.items()) #利用items获取所有键值对，而后以元组的形式进行返回。
losstest=loss
losstest['test']=214
loss#和列表一样，指向的是对象，对对象进行‘=’赋值，会修改原来的元组。而使用copy(）可以对字典进行复制。
test2=loss.copy()#使用copy进行复制的话，不会出现‘=’赋值的情况
#set()函数创建的集合，就相当于键一样。set创建的集合不包含重复值。
drinks={'coffe':{'tang','shui','eryanghuatan',',binqilin'},
'xuebi':{'tang','fengmi','erha','zhenzhu'},
'kele':{'shui','fanqie','xihongshi','huanggua'},
'naicha':{'shui','huanggua','tang'}
}
for name,contents in drinks.items():
if 'shui' in contents:
print(name) #利用 for in 语句进行内容的提取。
for name,contents in drinks.items():
if 'shui' in contents and not('huanggua' in contents or 'xihongshi' in contents):
print(name) #利用的是链接数据进行的不在一个集合。
#合并运算发。
for name,contents in drinl.items():
if contents&{'shui','xihongshi'}: #通过表达式&来判断两者之间情况。
print(name)
#通过特殊符号&或者集合函数intersection()获取集合的交集（两集合共有的元素）
a={1,2}
b={2,3}
a & b
a.intersection(b) #以上结果都为2
a|b
a.union(b)#以上结果都为1,2,3；所谓的并集
a-b
a.difference(b)#以上结果出现在差集上，出现在第一个集合不出现在第二个集合。
a^b
a.symmetric_difference(b)#本系列出现的是亦或集。
a>=b issuperset() #对其数据进行判断是否为其真子集。
# python ‘\’链接符，用于程序的最后'\'
value=input('Integer,please[ q to break]:')
if value=='q':
break
number=int(value)
if number % 2==0:
continue
print(number,"squared is",number*number) #python 小程序,执行跳出操作行为。
#zip() 函数利用填充列表。
days=['mondey','tuesday','wednesday']
fruits=['banana','orange','peach']
drinks=['tiramisu','ice cream','pie','pudding']
desserts=['tiramisu','ice cream','pie','pudding']
for day,fruit,drink,dessert in zip(days,fruits,drinks,desserts):
print(day,":drink",drink,"-eat",fruit,"- enjoy",dessert)
english='Mondey','Tuesday','Wednesday'
french='lundi','Mardi','Mercrdit'
list(zip(english,french)) #创建列表
list(zip(english,french)) #创建字典
#range(start,stop,step) 开始，结束，步长
for x in range(0,10):
print(x)
#生成反向序列
for x in range(2,-1,-1):
print(x)
#生成0到10的偶数值
for x in range(0,10,2):
print(x)
#列表推导式
text3=[number for number in range(0,10,2)]
list(text3)
text4=[number-1 for number in range(0,10,2)]
list(text4) #列表推导式中的数据可以利用公式进行换算
text5=[number for number in range(0,10,1) if number % 2==1]
list(text5) #如果number除以2得到余数为1，则选取其序列数字
rows=range(1,4)
cols=range(1,3)
cells=[(row,col) for row in rows for col in cols]
for cell in cells:
print(cell)
for row,col in cells:
print(row,col)#提出元组的元素
word='letters'
letter_counts={letter:word.count(letter) for letter in word}
letter_counts #对字符串的出现次数进行统计。
a_set={number for number in range(1,6) if number % 3==1}
a_set #集合推导式
import MYSQLdb
$ cd MySQL-python-1.2.3
$ python setup.py build
$ python setup.py install
#像高手一样玩转数据
def unicode_test(value):
import unicodedata
name=unicodedata.name(value)#name 接受一个unicode字符，返回大写形式标准名称
value2=unicodedata.lookup(name)#根据大小标准名称，返回unicode字符
print('value="%s",name="%s",value2="%s"'%(value,name,value2))
unicode_test('A')
unicode_test('\u2603')
n=42
g=7.03
s='string cheese'
#python 3.0以上的数据格式
'{}{}{}'.format(n,f,s)
'{2}{0}{1}'.format(n,f,s)
'{2}{0}{1}'.format(f,s,n) #利用位置进行定位输出函数。
'{n}{f}{s}'.format(n=42,f=7.03,s='string cheese') #利用赋值变量进行格式的转化
d={'n'=42,'f'=7.03,'s'='string cheese'}
'{0:f}{1:f}{2:s}'.format(n,g,s) #对格式进行转化,这里使用的是位置参数
'{n:10d}{f:20f}{s:30s}'.format(n=42, f=7.03,s='this is chinese')#默认为右对齐。
'{n:>10d}{f:>20f}{s:>30s}'.format(n=42, f=7.03,s='this is chinese')#同上，右对齐
'{n:<10d}{f:<20f}{s:<30s}'.format(n=42, f=7.03,s='this is chinese')#左对齐。
'{n:^10d}{f:^20f}{s:^30s}'.format(n=42, f=7.03,s='this is chinese')#居中对齐。
'{n:<10d}{f:<10.4f}{s:<10.4s}'.format(n=42, f=7.03,s='this is chinese')#精度的判断，整数不可以有精度
#浮点数可以有精度，代表小数位，字符串代表从宽度10中取出4个字符
'{n:!^20s}'.format(n='PYTHON')#填充字符在：之后左右对齐之前。
import re
result=re.match('You','Young Frankenstein') #这里的You是模式，’Young Frankenstein‘ 是源
youpattern=re.compile('You')
result=youpattern.match('You Frankstein') #鉴于复杂的匹配，可以先对模式进行编译以加快匹配速度：
#match 的含义是查看源是否以模式开头
#search()会返回第一次成功匹配，如果存在的话；
#findall()会返回所有不重叠的匹配，如果存在的话
#split()会根据pattern 将source模式切分成若干段，返回由这些片段组成的列表；
#sub()还需一个额外的参数replacement，它会把source中所有匹配的pattern改成replacement。
import re
source ='Young Frankenstein'
m=re.match('You',source)
if m:
print(m.group())
m=re.search('Frank',source)
if m:
print(m.group())# search检测任何地方
m=re.match('.*Frank',source)
if m:
print(m.group())
#'.'代表任何单一字符
#‘*’代表任意一个他之前的字符，".*"代表多个字符
m=re.findall('n',source)
m
print('Found',len(m),'matches')
#利用findall返回一个列表，他是查找多次全部的意思
m=re.findall('n.',source)
m #通过n.进行查找，但最后一个没有匹配要记得“.”代表一个字符
m=re.findall('n.?',source)
m #这一次最后一个字符n出现了
m=re.split('n',source)
m #使用split根据字符进行切割或者字符串。
m=re.sub('n','?',source)
m #使用sub利用模式进行替换
#\d 一个数字字符
#\D 一个非数字字符
#\w 一个字母或数字字符
#\W 一个衣蛾非字母非数字字符
#\s 空白符
#\S 非空白符
#\b 单词边界（一个\w与\W之间的范围，顺序可逆）
#\B 非单词边界
import string
printable=string.printable
len(printable)
printable[0:50]
re.findall('\d',printable)#判断哪些是数字
re.findall('\w',printable)#判断字母数字，下划线
re.findall('\s',printable)#输出空格符
#abc 文本值abc
#(expr) expr
#expr1|expr2 expr1或者expr2
# . 除\n外的任何字符
# ^ 源字符串的开头
# $ 源字符串的结尾
# prev? 0个或1个prev
# prev* o个或多个prev,尽可能多滴匹配
# prev*? 0个或多个prev,尽可能少地匹配
# prev+ 1个或多个prev，尽可能多滴匹配
# prev+? 1个或多个prev，尽可能少地匹配
# prev{m} m个连续的prev
# prev{m,n} m到n个连续的prev,尽可能多地匹配
# prev{m,n} m到n个连续的prev，尽可能少滴匹配
#[abc] a或b或c(和a|b|c一样)
#[^abc] 非（a或b或c）
#prev(?=next) 如果后面为next，则返回prev
#prev(?!next) 如果后面非next，则返回prev
#（?<=prev）next 如果前面为prev，返回next
#(?<!prev)next 如果前面非prev，返回next
source='''I wish I may,I wish I might
Have a dish of fish tonight.'''
import re
re.findall('wish',source)
re.findall('wish|fish',source)
re.findall('^wish',source) # 从字符串源头开始匹配
re.findall('^I wish',source) # 从字符串源头开始匹配
re.findall('fish$',source)
re.findall('fish tonight.$',source)
re.findall('[wf]ish',source)
re.findall('[wsh]+',source)
re.findall('ght\W',source) #非字母匹配
re.findall('ght\w',source) #字母匹配
re.findall('I (?=wish)',source)
re.findall('(?<=I) wish',source)
re.findall('\bfish',source)
re.findall(r'\bfish',source) #在正则表达式前使用r，代表禁用转义字符，而使用正则表达式
m=re.search(r'(. dish\b).*(\bfish)',source)
m
m.group()
m.groups()
#(?P<name>expr) 这样的模式会匹配expr，并将匹配结果存储到名为name的组中：
m=re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)',source)
m.group()
m.groups()
m.group('DISH');
m.group('FISH');
以上代码可以直接复制黏贴到py3.0上运行测试。