python进阶

第1次写博客，格式调的不太好，图片也是后来一张张加进去的。本篇文章是word复制过来的，若有什么不懂地方，可以及时提出。

1  def编写函数

1.1  模块与模块的常用方法

1.1.1    __init__.py文件

创建python包的过程中，IDE都会在包根目录下创建一个__init__.py文件，文件默认是空的。

__init__.py文件的作用：

1.     package的标识，如果没有该文件，该目录就不会认为是package，将无法被导入（from python_study import xxx）。

解释：每个package实际上是一个目录（Directory)。利用本文件标志此处为一个独立的目录。此时不能删除。

2.     定义package中的__all__，用来模糊导入。

解释：模糊导入：from python_study import *。

3.     编写Python代码。

解释：不建议在__init__中写python模块，可以在包中在创建另外的模块来写，尽量保证__init__.py简单）

1.1.2    __name__方法

单个功能：__name__可以获取函数名称。

1.1.3  if __name__ == '__main__'方法

1.     场景：python脚本中在最后的部分会执行一个判断语句if __name__ =="__main__:"，之后还可能会有一些执行语句。

2.     功能1：判断是否为主函数：if__name__==‘__main__’（程序需要先调用主文件）。

3.     功能2：通俗的理解__name__ == '__main__'：假如你叫小明.py，在朋友眼中，你是小明(__name__== '小明')；在你自己眼中，你是你自己(__name__ =='__main__')。

if __name__ == '__main__'的意思是：

(1)当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；

(2) 当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

举例说明：

①     原始函数编写：

2个文件，const.py文件提供参数值π，area.py文件计算面积值（用到π）。

分析：如上发现，导入const.py文件的area.py，被迫输出const.py输出的结果。如果想让该文件不输出被导文件的值，就要在被导文件中，加上if__name__ == '__main__'。

②     改进的函数：

4.     意义：让你写的脚本模块既可以导入到别的模块中用，另外该模块自己也可执行。

1.1.4    __file__方法/ __doc__方法

file功能：获取当前文件路径。

doc功能：获取文件描述。

1.2  函数式编程

1.2.1        def 定义函数

关键字def引入了一个函数定义。它必须跟随函数名称和形式参数的括号括起来的列表。构成函数主体的语句从下一行开始，并且必须缩进。

1.2.2     return返回值

返回数值而不输出，需要主动接收。

1.2.3     *args可变参数

   多个实参，放到一个元组里面,以*开头，可以传多个参数；

**是形参中按照关键字传值把多余的传值以字典的方式呈现.

 

1.2.4     del删除元素

del是用来删除变量的引用，而不是数据。用于list列表及字典操作。del不仅可以删除list中的某一个元素，也可以删除一个list,一个变量，或者类的实例。

【传递数值】：元素的索引位置

 

1.2.5     pop()移除元素

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

【传递数值】：元素的索引位置

1.2.6    remove删除元素

remove() 函数用于移除列表中某个值的第一个匹配项。

【传递对象】：元素本身

1.2.7     条件表达式（三元）

small = 表达式2  if表达式1 else 表达式3

①     如果表达式1为真，结果就是表达式2；

②     如果表达式1为假，结果就是表达式3.

1.2.8    assert断言

assert 表达式

①     当表达式为假时，抛出异常（自爆）；

②     当表达式为真时，直接pass（通过）。

【适用场景】：在程序中加入检查点。

2     常用的第三方库

2.1  collections集合

包含了dict、set、list、tuple以外的一些特殊的容器类型：

①         计数器(Counter) ②         双向队列(deque) ③         默认字典(defaultdict) ④         有序字典(OrderedDict) ⑤        可命名元组(namedtuple)

2.1.1     Counter：计数器

Counter是一个简单的计数器，返回一个字典，键值为【元素】：【值】为元素个数。

2.1.1.1      统计已有字符出现的个数

①     输出所有元素的个数：

②     输出某个元素的个数：

2.1.1.2      增加参与计数的内容：update()

使用update()方法：update 和set集合的update一样,对集合进行并集更新。

2.1.1.3      减少参与计数的内容：subtract()

使用subtract()方法：substract 和update类似，只是update是做加法，substract做减法,从另一个集合中减去本集合的元素。

2.1.1.4      迭代生成元素：elements()

使用elements()：返回经过计数器Counter后的元素，返回一个迭代器。

元素被重复了多少次，在该迭代器中就包含多少个该元素。元素排列无确定顺序，个数小于1的元素不被包含。

 

2.1.1.5      迭代生成字典：most_common(int)

使用most_common(int) ：按照元素出现的次数进行从高到低的排序,返回前int个元素的字典。如果n没有被指定，则返回所有元素。当多个元素计数值相同时，排列是无确定顺序的。

2.1.1.6      键的删除：del

当计数值为0时，并不意味着元素被删除，删除元素应当使用del。

2.1.1.7      浅拷贝copy()

2.1.2     deque：双向队列

高效实现插入和删除操作的双向列表。

1.       clear： 清空队列中的所有元素

2.       count(value)：返回队列中包含value的个数,结果类型为 integer

3.       extend：extend 队列右边扩展,可以是列表、元组或字典，如果是字典则将字典的key加入到deque

4.       pop ： 移除并且返回队列右边的元素

5.       popleft ：移除并且返回队列左边的元素

6.       remove(value)： 移除队列第一个出现的元素（从左往右开始的第一次出现的元素value)

7.       reverse： 队列的所有元素进行反转

2.1.3       defaultdict：默认字典

默认字典,是字典的一个子类,继承有字典的方法和属性,默认字典在进行定义初始化的时候可以指定字典值得默认类型：

2.2  itertools迭代

迭代器特别适合于遍历大文件或无限集合等。

itertools 模块包含了一系列用来产生不同类型迭代器的函数或类，这些函数的返回都是一个迭代器，可以通过 for 循环来遍历取值，也可以使用next() 来取值。

itertools 模块提供的迭代器函数有以下几种类型：

①         【无限迭代器】：生成一个无限序列，比如自然数序列 1, 2, 3, 4, ...； ②         【有限迭代器】：接收一个或多个序列（sequence）作为参数，进行组合、分组和过滤等； ③         【组合生成器】：序列的排列、组合，求序列的笛卡儿积等；

2.2.1           无限迭代器

itertools 模块提供了三个函数（事实上，它们是类）用于生成一个无限序列迭代器：

(1)   count(start =0, step=1)创建一个从 start (默认值为 0) 开始，以 step (默认值为 1)为步长的的无限整数迭代器。 (2)   cycle(iterable)对 iterable 中的元素反复执行循环，返回迭代器。 (3)   repeat(object [,times]反复生成 object，如果给定 times，则重复次数为 times，否则为无限。

2.2.1.1      count：输出迭代整数

itertools.count(start, step) 【解释】起始参数(start)默认值为0 步长(step)默认值为1 【作用】返回以start开头的均匀间隔step步长的值

     

2.2.1.2      cycle：循环输出列表内元素

itertools.cycle(iterable) 【解释】iterable 为可迭代对象 【作用】保存迭代对象的每个元素的副本，无限的重复返回每个元素的副本

     

2.2.1.3      repeat：重复输出整个列表

itertools.repeat(object[, times]) 【解释】object为可迭代对象 times为迭代次数，默认为无限次 【作用】按照指定的迭代次数重复返回每次的迭代对象

    

2.2.2           有限迭代器

itertools 模块提供了多个函数（类），接收一个或多个迭代对象作为参数，对它们进行组合、分组和过滤等：

chain()        compress()    dropwhile()    groupby()    ifilter()    filterfalse()    islice()       imap()        starmap()     tee()         takewhile()    izip()         izip_longest()     -------> 13 个

2.2.2.1      chain：连接列表+输出元素

chain 接收多个可迭代对象作为参数，将它们『连接』起来，作为一个新的迭代器返回。

itertools.chain(*iterables) 【解释】*iterables为一个或多个可迭代序列 【作用】返回所有可迭代序列

     

2.2.2.2      compress：数据筛选

compress 可用于对数据进行筛选，当 selectors 的某个元素为 true 时，则保留 data 对应位置的元素，否则去除。

itertools.compress(data, selectors) 【解释】data为数据对象 selectors为选择器(规则) 【作用】返回数据对象中对应规则为True的元素

      

2.2.2.3      dropwhile：查找不合条件的数

找到【第一个】不符合条件的数据及之后的数据。

itertools. dropwhile(predicate, iterable) 【解释】predicate 是函数 iterable 是可迭代对象。 【作用】对于 iterable 中的元素，如果 predicate(item) 为 true，则丢弃iterable内的元素，否则返回该项及所有后续项。

        

2.2.2.4      groupby ：对序列进行分组

itertools. groupby(iterable[, keyfunc]) 【解释】iterable 是一个可迭代对象 keyfunc 是分组函数，用于对 iterable 的连续项进行分组 【作用】返回一个 (key, sub-iterator) 的迭代器。

keyfunc 是分组函数，用于对 iterable 的连续项进行分组，如果不指定，则默认对 iterable 中的连续相同项进行分组，返回一个 (key,sub-iterator) 的迭代器。

2.2.2.5      ifilter：过滤并返回正确的

将不符合条件的信息过滤掉，返回正确的信息。

itertools. ifilter(function or None, sequence) 【解释】function是函数 sequence是可迭代对象。 【作用】iterable 中 function(item) 为 True 的元素组成一个迭代器返回，如果 function 是 None，则返回 iterable 中所有计算为 True 的项。

2.2.2.6      filterfalse：过滤并返回错误的

将符合条件的信息过滤掉，返回不符合条件的信息。

iterable 中 function(item) 为 True 的元素组成一个迭代器返回，如果 function 是 None，则返回 iterable 中所有计算为 False 的项。

2.2.2.7      islice ：切片选择

itertools. islice(iterable, [start,] stop [, step]) 【解释】iterable 是可迭代对象 start 是开始索引，stop 是结束索引 step 是步长（start 和 step 可选） 【作用】返回切片内容

     

2.2.2.8      imap：返回功能执行后的值

itertools.imap(function, *iterables) 【解释】function为功能函数 *iterables为可迭代序列 【作用】返回迭代序列中每个元素被功能函数执行后的值

2.2.3           组合生成器

itertools 模块还提供了多个组合生成器函数，用于求序列的排列、组合等：

(1) product (2)permutations (3)combinations (4)combinations_with_replacement

2.2.3.1      product: 笛卡尔积

product 用于求多个可迭代对象的笛卡尔积，它跟嵌套的 for 循环等价。

itertools.product(*iterables[, repeat]) 【解释】*iterables为迭代器(对象) repeat指定重复生成序列的次数，默认为1 【作用】对迭代对象中元素进行笛卡尔积运算

     

2.2.3.2      permutations: 排列

permutations 用于生成一个排列：

itertools.permutations(iterable[, r]) 【解释】iterable是迭代器(对象) r是迭代长度，默认为可获得的最大长度迭代 【作用】返回连续长度为r的的迭代器(对象)

    

2.2.3.3      combinations：组合

combinations 用于求序列的组合：

itertools. combinations (iterable[, r]) 【解释】iterable是迭代器(对象) r 指定生成组合的元素的长度 【作用】返回连续长度为r的的迭代器(对象)

     

2.3  time &datetime时间

Python提供了多个内置模块用于操作日期时间,像calendar,time,datetime模块。

2.3.1           time()模块

time()模块提供各种操作时间的函数。

一般有两种表示时间的方式:

（1）   第一种是【时间戳】的方式(相对于1970.1.100:00:00以秒计算的偏移量),时间戳是惟一的；

（2）    第二种以【数组】的形式表示即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同。

常用标准库：

time：     1、 时间戳:时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量；     2、格式化的时间字符串；     3、元组（struct_time）：struct_time元组共有9个元素。

格式：    %a    本地（locale）简化星期名称      %A    本地完整星期名称      %b    本地简化月份名称      %B    本地完整月份名称      %c    本地相应的日期和时间表示      %d    一个月中的第几天（01 - 31）      %H    一天中的第几个小时（24小时制，00 - 23）      %I    第几个小时（12小时制，01 - 12）      %j    一年中的第几天（001 - 366）      %m    月份（01 - 12）      %M    分钟数（00 - 59）      %p    本地am或者pm的相应符       %S    秒（01 - 61）       %U    一年中的星期数。（00 - 53星期天是一个星期的开始）； 第一个星期天之前的所有天数都放在第0周。         %w    一个星期中的第几天（0 - 6，0是星期天）       %W    和%U基本相同，不同的是%W以星期一为一个星期的开始。      %x    本地相应日期      %X    本地相应时间      %y    去掉世纪的年份（00 - 99）      %Y    完整的年份      %Z    时区的名字（如果不存在为空字符）      %%    ‘%’字符

2.3.1.1      time.time():时间戳

当前时间 时间戳

2.3.1.2      time.sleep(1): 延迟

延迟多少秒

2.3.1.3      time.gmtime()：数组格式

返回元组格式的时间UTC

2.3.1.4      time.localtime()：数组格式

元组格式的时间 UTC+8

2.3.1.5      time.strftime(): 自定义格式

将元组格式的时间格式化为str格式的自定义格式时

time.strftime(str_format, x)  【解释】str_format:格式   x元组时间

2.3.1.6      time.ctime()：字符串格式

秒格式化为字符串形式。格式为：Tue Jun 16 11:53:31 2009

2.3.1.7      x.tm_year：获取具体时间

获取元组时间中的具体时间  年/月/日......

x.tm_year, x.tm_mon, x.tm_mday, x.tm_hour, x.tm_min, x.tm_sec  【解释】年月日，时分秒

     

2.3.2           datetime()模块

datetime类 

 datetime是date与time的结合体，包括date与time的所有信息。 

它的构造函数如下： datetime. datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )  各参数的含义与date、time的构造函数中的一样，要注意参数值的范围。

 

2.4  random随机数

2.4.1     random.random()：0到1的随机浮点数

用于生成一个0到1的随机符点数: 0 <= n < 1.0

2.4.2     random.randint(1,10)：不含步长随机整数

random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

2.4.3     random.randrange(1, 10，2)：含步长的随机数

random.randrange([start], stop[, step])， 【意义】从指定范围内，按指定基数递增的集合中 获取一个随机数。 如：random.randrange(10, 100, 2)， 结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。 random.randrange(10, 100, 2) 等价于 random.choice(range(10, 100, 2))

2.4.4     random.choice()：随机字符串

从序列中获取一个随机元素。random.choice(sequence) sequence在python不是一种特定的类型，而是泛指一系列的类型。 list, tuple, 字符串都属于sequence（顺序存储类型）

2.4.5    random.sample(m，n)：选取n个字符

random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。

2.4.6    random.uniform(1, 10)：随机浮点数

2.4.7     random.shuffle(items)：打乱顺序

2.4.8       实例：生成验证码

2.5  re：正则表达式

正则表达式是用来匹配处理【字符串】的。

正则表达式： ①         '.'  默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行 ②         '^'匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE) ③         '$'  匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以 ④         '*'  匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a'] ⑤         '+'   匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb'] ⑥         '?'   匹配前一个字符1次或0次 ⑦         '{m}' 匹配前一个字符m次 ⑧         '{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb'] ⑨         '|'   匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC' ⑩         '(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c ⑪         '\A'   只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的 ⑫         '\Z'   匹配字符结尾，同$ ⑬         '\d'   匹配数字0-9 ⑭         '\D'   匹配非数字 ⑮         '\w'   匹配[A-Za-z0-9] ⑯         '\W'   匹配非[A-Za-z0-9] ⑰         '\s'    匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'

匹配模式：    re.I:忽略大小写    re.M;多行模式，改变'^'和'$'的行为    re.S:点任意匹配模式，改变'.'的行为

2.5.1           re：正则匹配

2.5.1.1       () 定义组

() 表达式用于定义一个group,一个正则表达式中可以有多个括号表达式,这就意味着匹配结果中可能有多个group,我们可以用group函数来定位到特定的group结果。

2.5.1.2      group输出组

group()在正则表达式中用于获取分段截获的字符串。

       

模式：group([group1,…]) 【解释】1. 正则表达式中的三组括号把匹配结果分成三组：        group() 同group（0）就是匹配正则表达式整体结果，        groups返回所有的group,以元组的形式，        group(1) 列出第一个括号（group）匹配部分， group(2) 列出第二个括号（group）匹配部分， group(3) 列出第三个括号（group）匹配部分。 2. 没有匹配成功的，re.search()返回None

 

2.5.1.3      re.compile匹配正则规则

在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。

匹配模式：re.compile(string[,flag]) 【解释】flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。

   

2.5.1.4      re.match 从头开始匹配

re.match 尝试从字符串的开始匹配一个模式。

匹配模式： re.match(pattern, string, flags) 【解释】第一个参数是正则表达式,如果匹配成功，则返回一个Match，否则返回一个None； 第二个参数表示要匹配的字符串； 第三个参数是标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

      

解释：

^A：以A开头的字符串； n$：以n结尾的字符串； \d： 匹配数字0-9 {1,7}：匹配前一个字符1到7次 +：   匹配前一个字符1次或多次

\w：匹配[A-Za-z0-9] *： 匹配*号前的字符0次或多次 |：或（左边，右边任选一个） {17}： 匹配前一个字符17次 x|X：小写x或大写X

2.5.1.5      re.search 匹配包含

re.search会在给定字符串中寻找第一个匹配给定正则表达式的子字符串。

匹配模式： re.search(pattern, string, flags=0) 【解释】第一个参数是正则表达式,如果匹配成功，则返回一个Match，否则返回一个None； 第二个参数表示要匹配的字符串； 第三个参数是标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

     

解释：

连接2个类型不同的字符，直接写就行，不用添加+号;

a？：匹配(a)前一个字符1次或0次 [a-zA-Z]：匹配范围a-zA-Z

 

2.5.1.6      re.findall 把所有匹配到的字符放到以列表中的元素返回

浏览全部字符串，匹配所有合规则的字符串，匹配到的字符串放到一个列表中，未匹配成功返回空列表

匹配模式： re. findall (pattern, string, flags=0) 【解释】第一个参数是正则表达式,如果匹配成功，则返回一个list，否则返回一个[]； 第二个参数表示要匹配的字符串； 第三个参数是标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

     

解释：

. ：默认匹配除\n之外的任意一个字符

2.5.1.7      re.split 分割字符串

根据正则匹配分割字符串，返回分割后的一个列表。

匹配模式：re.split(pattern, string, maxsplit=0, flags=0) 【解释】pattern： 正则模型 string ： 要匹配的字符串  maxsplit：指定分割个数 flags  ： 匹配模式

      

2.5.1.8      re.sub 匹配字符并替换

将匹配到的值替换为指定字符 可以指定【替换次数】

匹配模式：sub(pattern, repl, string, count=0, flags=0) 【解释】pattern： 正则模型 repl   ： 要替换的字符串  string ： 要匹配的字符串 count  ： 指定匹配个数 flags  ： 匹配模式

      

2.5.2           re：分组

print中的字符串前面加r，表示禁止字符串转义。

2.5.2.1      .group(n) 序号分组

注意：括号所在的位置

2.5.2.2      ?P<name>：为匹配项加名字

注意：P为大写的。

                                     

模式：(?P<name>正则表达式) 【解释】正则表达式的名字为name 【注意】和普通的圆括号类似，但是子串匹配到的内容将可以用命名的name参数来提取。 组的name必须是有效的python标识符，而且在本表达式内不重名。 命名了的组和普通组一样，也用数字来提取，也就是说名字只是个额外的属性。

2.5.2.3      .groupdict正则字典

返回匹配到的所有命名子组的字典。Key是name值，value是匹配到的值。

模式：groupdict([default]) 【解释】default表示没有截获字符串的组以这个值替代，默认为None

                                         

                                        

2.5.2.4      groupindex

一个字典，定义了命名组的名字和序号之间的关系。

例子：这个正则有3个组，如果匹配到，第一个叫区号，最后一个叫分机号，中间的那个未命名。

2.5.3           re：编译正则

利用re.compile.

编译：当我们使用正则表达式时，re模块会干两件事：

①  编译正则表达式，若正则表达式本身不合理，会报错；

② 用编译后的正则表达式去匹配对象。

 

2.6  xml：解析xml文件

xml处理模块:xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，很多系统的接口还主要是xml。

2.6.1           路径分析

2.6.1.1      相对路径

主要说明：针对pycharm软件中的相对路径。

1.     同级文件夹下面的路径描述（同一个文件夹）

└── xml_0     ├── datas     │   └── xml_test.xml     └── xml_1.xml  问题：在xml_1.xml文件中找到xml_test.xml文件

方法一：./datas/xml_test.xml

方法一：datas/xml_test.xml

                                     

2.     上一级文件夹的路径描述

└── python     ├── datas     │   └── xml_test.xml     └── xml_0          └── xml_1.xml 问题：在xml_1.xml文件中找到xml_test.xml文件

方法：.. /datas/xml_test.xml

                                      

2.6.1.2      绝对路径

绝对路径，指的是文件在本地计算机里面的路径（包括磁盘位置），一般比较长。

2.6.2           构建XML文件

新建一个xml文件。

元素	解释
ElementTree(tag)	表示整个xml节点树。其中tag表示根节点，初始化一个ElementTree对象。
Element(tag, attrib={}, **extra)	构造xml的一个根节点，其中tag表示根节点的名称，attrib是一个可选项，表示节点的属性
SubElement(parent, tag, attrib={}, **extra)	构造一个已经存在根节点的子节点。 Element.text和SubElement.text表示element（元素）对象的额外的内容属性，Element.tag和Element.attrib分别表示element对象的标签和属性
导入包：import  xml.etree.ElementTree  as  ET（给包重命名为ET） 写入方法：ElementTree.write(file, encoding='us-ascii', xml_declaration=None, default_namespace = None, method='xml') 【作用】函数新建一个XML文件，并且将节点数数据写入XML文件中。

2.7  OS操作系统

提供对操作系统进行调用的接口。

2.8  sys模块

sys模块提供了一系列有关Python运行环境的变量和函数。

区分：

l os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口;

l sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

3     连接数据库

3.1  前言

连接数据库有两个模块（MySQLdb或pymysql），都需要从外面导入；

两种模块用法相似，但是MySQLdb不兼容python3，而pymysql同时兼容python2和python3.因此，我们采用pymysql模块。

3.2  连接数据库

3.2.1           连接数据库

1.     导入模块

import pymysql

2.     连接数据库

# 连接数据库 conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1', charset='utf8')  # db：数据库库名 # 创建游标 cur = conn.cursor() # 编写sql语句 sql = "insert into trade (name, account, saving) values ( '%s', '%s', %.2f )"  # trade为表名 data = ('雷军', '13512345678', 10000)  # 执行sql语句 cursor.execute(sql % data) # 提交sql语句 connect.commit()

# 关闭数据库 cur.close()   # 关闭游标指针 connect.close() # 关闭数据库连接

解释：

①       cursor是一个实现了迭代器和生成器的对象，可以获得数据库连接并且记录位置。cursor只能用一次，即释放(fetch)之后，就没有使用价值了

3.2.2           生成随机数

3.2.2.1      UUID的随机不重复组合

import uuid uuid=uuid.uuid1() print(uuid)

输出结果：39ecb962-5d8c-11e8-90e1-f48e389acf17

3.2.2.2      生成限定位数的数字

import random uuidd=str(random.randint(0,99999999)).zfill(8) print(uuidd)

输出结果：90546136

解释：zfill(8)：限制字符串的8位数

3.2.2.3      含有步长的随机数字

按步长随机在上下限范围内取一个随机数 random.randrange(20,100,5)

结果： 30/20/50

注意： random.randint(a,b) 返回指定范围的一个随机整数，只有上下限（没有步长）

 

3.2.2.4      限定生成的浮点数的位数

方法一：                                                                                                import random r = round(random.uniform(0, 4.5), 4)  print r

输出结果：4.0134

解释：uniform：生成随机浮点数 （0,4.5）：随机数的范围为：0~4.5 4：限定小数点后有4位数 round(x [, n]) 方法返回浮点数x的四舍五入值。 注意：此时结果依旧为浮点数

方法二： a = 1.23456789 b = "%.4f" % a      print b

结果：1.2346

解释：%.4f：限定浮点数有4位小数 注意：此时生成的为字符串

      

     

3.2.2.5      随机选择TXT文件中的行

#encoding=utf-8    #随机数，随机读取每一行的数据  import linecache    import random   for i in xrange(1,5):#for循环几次      a = random.randrange(1, 9) #1-9中生成随机数      print a      #从文件poem.txt中对读取第a行的数据      theline = linecache.getline(r'poem.txt', a)      print theline

结果：

3.2.2.6      取二维数组某一列的值

arr = [[1,2],[3,4],[5,6]] # 取第一列的值 v = [x[0] for x in arr]

结果： [1, 3, 5]

3.2.2.7      随机生成日期

生成随机的日期字符串，用于插入数据库。

通过时间元组设定一个时间段，开始和结尾时间转换成时间戳。

时间戳中随机取一个，再生成时间元组，再把时间元组格式化输出为字符串

import random a1=(1976,1,1,0,0,0,0,0,0)       #设置开始日期时间元组（1976-01-01 00：00：00） a2=(1990,12,31,23,59,59,0,0,0)  #设置结束日期时间元组（1990-12-31 23：59：59） start=time.mktime(a1)  #生成开始时间戳 end=time.mktime(a2)   #生成结束时间戳 #随机生成10个日期字符串 for i in range(10): t=random.randint(start,end)  #在开始和结束时间戳中随机取出一个  date_touple=time.localtime(t)     #将时间戳生成时间元组  date=time.strftime("%Y-%m-%d %H: %M: %S",date_touple) #将时间元组转成格式化字符串（1976-05-21） print(date)

结果： 1985-11-29 12:23:44 1990-08-29 12:23:44

3.2.2.8      日期加减操作

要想进行日期加减运算，必须把字符串转换为datatime类型。

import datetime b = datetime. datetime.strptime("2016-3-1", "%Y-%m-%d")  #生成datatime类型时间 c = b + datetime.timedelta(days = -2)   # 减去2天 print(c)

结果：2016-1-1

例子2： t= time.localtime(random.randint(start, end) fDay = time.strftime("%Y-%m-%d %H:%M:%S",))  # 生成字符串日期 b = datetime.datetime.strptime(fDay, "%Y-%m-%d %H:%M:%S") # 字符串改为可运算的datetime类型 day = random.randint(1, 7)  # 加上day天  （1,7） hour = random.randint(0, 23) # 加上hour时 （0,23） mint = random.randint(0, 59) # 加上mint分  (0, 59) sec = random.randint(0, 59) # 加上sec秒    (0, 59) processtime = b+datetime.timedelta(days=day,hours=hour,minutes=mint,seconds=sec) print(b)          # 输出加法之前的时间 print(processtime)  # 输出加法之后的时间

结果：2017-05-30 07:28:49       2017-06-02 03:45:27

 

3.2.2.9      添加数据库类型为datatime的数据

sql_insert="insert into tablename(exTime) values (str_to_date (\'%s\','%%Y-%%m-%%d %%H:%%i:%%s'))"   % (dt.strftime ("%Y-%m-%d %H:%M:%S"))  # 字符串

结果：插入成功

     

3.2.3           数据库查询

import pymysql conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='tkq1') cursor = conn.cursor() cursor.execute("select uuid from tb7") # 获取剩余结果的第一行数据 row_1 = cursor.fetchone() print row_1 # 获取剩余结果前n行数据 # row_2 = cursor.fetchmany(3) # 获取剩余结果所有数据 # row_3 = cursor.fetchall() conn.commit() cursor.close() conn.close()

结果：以多维元组形式显示。

3.2.4           sql语句

3.2.4.1      查询两张表中的相同字段数据

如果两张表没有关联并且只是想要相同字段的数据，下面的sql可以满足：

--自动去掉A，B表中相同的数据 select same_col from A union select same_col from B

--取A，B表的最大并集 select same_col from A union all select same_col from B

 

4        小技巧

4.1  分割符

方法一：利用 * 对分隔符进行倍乘。

方法二：利用center，ljust，rjust函数。

python lxml包用于解析XML和html文件，可以使用xpath和css定位元素，个人认为相对于BeautifulSoup功能更加强大，更加灵活。   围绕三个问题:

问题1：有一个XML文件，如何解析

问题2：解析后，如果查找、定位某个标签

问题3：定位后如何操作标签，比如访问属性、文本内容等

注意：python3：xml.etree模块； python2 ：lxml.etree模块。