Python--Day5

学习要有定位,明确目标地去学习。希望自己能坚持下去,并有所收获---leaves


python04 -- python基础知识总结以及函数进阶



一、python中获取帮助

    python中获取帮助的方法有两种：

     1.dir("数据类型") ===>看所有方法

    2.help("数据类型或者方法") ===>查看官方文档

##代码举例：


##dir()

>>> dir([])

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__',

 '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', 

 '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', 

 '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', 

 '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',

  '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count',

   'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']


##help()

help([].append)

Help on built-in function append:


append(...)

    L.append(object) -- append object to end


二、字典的高阶用法

   常用字典的两种高阶用法dict.get()和dict.setdefault()


   1.dict.get()    ==>主要作用是获取key对应的value值,若字典中无该key值则以给定的value赋予该key.且字典新增一对key，value值。


   2.dict.setdefault() ===>主要针对不存在的key设置默认值

##代码举例如下：


##dict.get()用法

In [9]: d = {"192.168":1}

In [10]: str = "192.168.1"

In [11]: d[str] = d.get(str,0)+1

In [12]: d

Out[12]: {'192.168': 1, '192.168.1': 1}

In [13]: str = "192.168"

In [14]: d[str] = d.get(str,0)+1

In [15]: d

Out[15]: {'192.168': 2, '192.168.1': 1}


##dict.setdefault()

for k ,v in res.items():

new.setdefault(v,[])

new[v].append(k)


三、list和dict的区别及相互之间的转换


3.1 list和dict的区别


相同点：都可以存储各种数据结构,可以嵌套

不同点：

    list 有序

        查找需要遍历,速度慢


    dict 没顺序

        查找非常迅速


3.2 list和dict的转换


    dict--->list    用items函数

    list --->dict  enumerate() 或者使用dict.fromkeys()函数

##具体代码如下：

##dict--->list 

In [17]: d.items()

Out[17]: [('192.168', 2), ('192.168.1', 1)]


##list --->dict 


##enumerate()

In [18]: l = list("hello")

In [19]: print dict((k,v) for k ,v in enumerate(l))

{0: 'h', 1: 'e', 2: 'l', 3: 'l', 4: 'o'}


##fromkeys()的用法

In [53]: d.fromkeys([1,2,3])

Out[53]: {1: None, 2: None, 3: None}

In [54]: d.fromkeys(['name','age'])

Out[54]: {'age': None, 'name': None}

In [55]: d

Out[55]: {'age': 12, 'name': 'test'}

In [56]: d.fromkeys(['one','two'],['1','2'])

Out[56]: {'one': ['1', '2'], 'two': ['1', '2']}

In [57]: d

Out[57]: {'age': 12, 'name': 'test'}

In [58]: d.fromkeys(d,['1','2'])

Out[58]: {'age': ['1', '2'], 'name': ['1', '2']}

In [59]: d

Out[59]: {'age': 12, 'name': 'test'}

In [60]: {}.fromkeys(d,[1,2,3])

Out[60]: {'age': [1, 2, 3], 'name': [1, 2, 3]}


四、文件的处理


4.1 python中文件的打开方式


    方法一：        

        f = open("a.txt")

        f.read()

        f.close()##这个模式操作文件要记得关闭文件,即一定有f.close()

    

    方法二：

         with open('a.txt') as f:  

            f.read()

        ###注意该方法提供了自动关闭文件的功能

        ###with可以同时打开多个文件

        

##使用with打开多个文件：


#方法一：

with open('file1') as f1:

    with open('file2') as f2:

        with open('file3') as f3:

            for i in f1:

                j = f2.readline()

                k = f3.readline()

                print(i,j,k)


#方法二：较为优雅

with open('file1') as f1, open('file2') as f2, open('file3') as f3:

    for i in f1:

        j = f2.readline()

        k = f3.readline()

        print(i,j,k)

        


##方法三：通过contextlib模块的

from contextlib import nested


with nested(open('file1'), open('file2'), open('file3')) as (f1,f2,f3):

    for i in f1:

        j = f2.readline()

        k = f3.readline()

        print(i,j,k)


4.2 文件的操作


    1.文件刚打开,指针在开始的地方，每次read ,readline ,readlines都会把指针移动到读取数据的地方

    2.seek() f.seek(0)#把指针移到文件开始

    3.tell() f.tell() #返回指针所在的位置


4.3 文件的注意事项

    

#'a'模式，每次都是从文件尾开始追加数据

#注意文件的'w'模式,打开文件的时候就清空文件了。


#打开大文件推荐使用readline()函数 或者for  line  in f

files.read() 每次读取整个文件 read可以传一个数字，表示读多少个字符。不传就是读整个文件

files.readline()每只读取文件的一行

files.readlines()每次按行读取整个文件内容,一次全部读取文件


五、python其它基础知识


5.1 元组


  元组:元组也可以嵌套任意类型的数据结构,但是元组不能修改,定义后不可改变,正是由于这种特性,元组这种数据类型可以作为字典的key,在nginx日志分析中用来统计多个维度(ip,url,code)等等。



5.2 遍历list的方法   


    1.直接遍历列表  for i   in  list  

    2. 根据索引值遍历  range()配合长度

    3. 高阶遍历方法同时获取索引值和值

    In [18]: for k ,v in enumerate(['one','two','three']):

       ...:     print k , v

 

    0 one

    1 two

    2 three


5.3 遍历dict的方法(目前只有一种方法)


    for  k ,v in dict.items():

        print k ,v



六、函数


    函数的定义:简单的理解就是一次执行很多行代码

    格式：当前def缩进模块中的所有内容都是函数内容

    def 函数名(参数)：

        函数内容


6.1 简单的函数举例


##python中简单的函数

In [13]: def hello():

    ...:     print "hello world"

    ...:     print "hi Bob"

    ...:     

In [14]: hello()

hello world

hi Bob


6.2 函数的返回值


###函数的返回值:定义,即为函数执行后的状态结果,与shell中的echo $?相等

print   hanshu   ==>函数功能、方法

print   hanshu() ===>函数的返回值


##代码练习

##定义函数hello()

In [15]: def hello():

    ...:     print "hello world"

    ...:     print "hi Bob"

    ...:     return '2016'

    ...: 


##直接print+函数名  的结果 ===>返回结果为对象

In [16]: print hello


##print + 函数名()  的结果 ===>返回函数的执行状态结果

In [17]: print hello()

hello world

hi Bob

2016


6.3 函数的参数：


    python中函数参数的种类1.必备参数  2.关键字参数  3.缺省值参数

    1.必备参数：调用函数时,必须以正确的顺序传入,并且传入的参数必须与声明的参数一致,否则可能出现错误参数调用的情况。


    2.关键字参数：关键字参数和函数调用关系紧密,函数调用使用关键字参数来确传入的参数值,使用关键字参数允许调用函数时参数的顺序和声明的时候不一致,因为python解释器能够用参数名匹配参数值。关键字参数的优点就是===>可读性好


    3.缺省值参数：调用函数时,如果缺省值参数没有传入的话,就是用预先定义的默认值。


###带参数的函数练习

##函数参数之一：必备参数 

In [20]: def hello(name,age):

    ...:     print "hello %s,you age is %s" %(name,age)

    ...:     return '2016'

    ...:     

    ...: 

In [21]: hello('test',13)

hello test,you age is 13

Out[21]: '2016'  <===out输出为函数的执行状态结果



##函数小练习==>写一个阶乘的函数

In [22]: def jiecheng(num):

    ...:     res = 1

    ...:     while num > 0:

    ...:         res *= num

    ...:         num -= 1 

    ...:     return res

    ...: 

In [23]: jiecheng(3)

Out[23]: 6

In [24]: jiecheng(4)

Out[24]: 24


##函数参数之二：关键字参数

In [25]: def hello(name='aaa',age=12):

    ...:     print "hello %s,you age is %s" %(name,age)

    ...:     return '2016'

    ...:     

    ...: 

In [26]: 

In [26]: hello(age=14,name='ccc')

hello ccc,you age is 14

Out[26]: '2016'



##函数参数之三:缺省值参数

In [25]: def hello(name='aaa',age=12):

    ...:     print "hello %s,you age is %s" %(name,age)

    ...:     return '2016'

    ...:     

    ...: 

In [26]: 

In [26]: hello(name='ccc')

hello ccc,you age is 14

Out[26]: '2016'


特殊参数情况：

    当函数希望收集不定长的参数时,即参数的个数不确定,则使用星号(*)来收集参数。星号(*)收集函数前边固定参数后剩下的所有参数。

    若函数收集的关键字参数也是个数不确定的话,则使用两个星号(**)来收集参数。


##特殊参数的代码详情


##一个星号(*)收集不定长参数


##情况一：注意*号收集前边参数收集后剩下的所有的参数

In [1]: def test(name,*num):

   ...:     print num

In [2]: test(1,2,3,4,5)

(2, 3, 4, 5)


##情况二：收集所有的参数

n [28]: def add_all(*num):

    ...:     sum = 0 

    ...:     for i in num:

    ...:         sum += i

    ...:     return sum

    ...: 

In [29]: add_all(1,2,3)

Out[29]: 6

In [30]: add_all(1,2,3,4,5,6)

Out[30]: 21



##两个星号(**)收集关键字的参数

##(**)开头  ,收集关键字参数

In [31]: def test(**arr):

    ...:     print arr

In [34]: test(name='aa',age=15)

{'age': 15, 'name': 'aa'}


6.4 函数的进阶,使用函数优化之前的单词统计代码


    python的核心思想是函数化编程,所以函数式拆分代码需要注意;尽量避免全局变量,尽量减少函数间的练习,提高函数的可读性。程序是给人读的。


###拆分代码为函数的注意事项：尽量避免全局变量

本人拆分统计单词读写文件的代码如下：

#coding:utf-8

res = {'!': 1, '.': 1, 'Bob': 1, 'I': 2, 'a': 1, 'am': 2, 'boy': 1}

new = {}

for k ,v in res.items():

new.setdefault(v,[])

new[v].append(k)

print new

#keys = max(new)

#print "%s  ----> %s" %(keys,new[keys])

def op_file(filename,mode='r'):

f = open(filename,mode)

str = "/usr/local/src/newbie/03==>result\n

\

       

"

while True:

keys = max(new)

for i in new[keys]:

str += "

" %(keys,i)

new.pop(keys)

if len(new) == 0 :

break

str += "

timesword
%s%s
\n"

if ('w' in mode) or ('a' in mode) : ##使用in来判断模式是否为写模式

f.write(str)

f.close()

op_file(filename='/var/www/html/tongji.html',mode="w+")


6.5 变量的作用域


    讲到函数不得不引申下变量的作用域问题,一般编程语言中变量都分为全局变量和局部变量。具体定义自己可以百度了解些许,此处一带而过,python中全局变量使用关键词global来定义,一般在函数内部定义全局变量。


##global定义全局变量

[root@xiaowei 04]# cat a.py 

num = 3

def hello():

global num 

num = 5

print num

print hello()

print "num = %s" %num

[root@xiaowei 04]# python a.py 

5

None

num = 5



七、python语言中关于排序的进阶


    简而言之,冒泡排序、插入排序等一系列算法仅仅是编程语言的基础原理,而在python中可以通过简单的一两行代码实现复杂数据结构的排序。接下来将一步一步深入python排序原理及通间易读代码的实现。


7.1 以nginx日志统计完ip后得到的结果字典为例 

 

res = {'111.85.41.230': 103, '218.200.66.197': 21, '218.200.66.196': 14, '221.176.5.153': 31, '218.200.66.199': 19, '218.200.66.198': 25, '221.176.5.156': 3, '10.35.1.82': 61, '221.176.5.154': 3, '220.181.125.177': 1, '101.227.4.33': 2, '220.172.215.69': 1}


思路有两种：

    1.将字典翻转,即以出现的次数为key，value值为ip，但是需要注意的时这种情况,需要将ip存放到事先准备的空列表中去,否则key为ip出现次数的话,若有两个ip出现次数相同,那么会出现值被覆盖的情况从而使结果有所偏差。翻转后使用max(dict)取出最大次数的value值列表,拼接成html网页元素,然后dict.pop(keys)去掉最大值的key以此轮训依次出现最大ip的情况。---By  Panda

    

    2.上述res字典可以通过用dict.items()将res字典转换为元组组成的列表,然后通过对列表中每个元素中代表次数的项进行排序。然后根据排序结果拼接html元素。--By woniiu


接下来主要深入woniu的思想为主线从而引出最终主人公python自带的sorted()函数。


7.1.1 冒泡法实现排序：


tmp = res.items()

tmp = [('218.200.66.197', 21), ('218.200.66.196', 14), ('218.200.66.199', 19), \

    ('218.200.66.198', 25), ('101.227.4.33', 2), ('111.85.41.230', 103), \

    ('220.181.125.177' , 1), ('220.172.215.69', 1)，('221.176.5.153', 31), \

    ('221.176.5.156', 3), ('10.35.1.82', 61), ('221.176.5.154', 3)]

##原始的冒泡排序代码：

d = {'10.35.1.82': 61, '101.227.4.33': 2, '111.85.41.230': 103,'218.200.66.196': 14,\

    '218.200.66.197': 21,'218.200.66.198': 25,'218.200.66.199': 19,'220.172.215.69': 1,\

    '220.181.125.177': 1,'221.176.5.153': 31,'221.176.5.154': 3,'221.176.5.156': 3}

    

tmp = d.items()

print tmp

le = len(tmp)

for i in range(le-1):

        for j in range(le-1-i):

                if tmp[j][1] < tmp[j+1][1]:

                        tmp[j],tmp[j+1] = tmp[j+1],tmp[j]

print "sorted tmp :%s" %tmp


##排序后通过切片获取自己想要打印的数据。

tmp = tmp[:3]

for i in tmp:

        print "ip is %s ,count is %s" %i



7.1.2 通过函数方法实现冒泡排序；

用函数实现冒泡排序bubble_sort() 

###代码：

def bubble_sort(tmp,le,num=3):

        for i in range(le-1):

                for j in range(le-1-i):

                        if tmp[j][1] < tmp[j+1][1]:

                                tmp[j],tmp[j+1] = tmp[j+1],tmp[j]

        tmp = tmp[:num]

        return tmp

le = len(tmp)

res = bubble_sort(tmp,le,num=4)


7.3 函数的进阶


    ###进阶排序函数===>函数可以当作参数传递给另一个函数


具体实现代码如下：


##以函数为参数传递给函数


[root@xiaowei sorted]# cat sort_fn.py 

#coding:utf-8

##原始数据

arr = [1,3,65,2,6,32,0,7,14]


##列表嵌套元组

arr2 = [('xiaohong',90),('xiaohua',58),('xiaohei',100)]


##列表嵌套字典

d = [{'name':'xiaohong','age':18},{'name':'xiaohei','age':10},{'name':'xiaowang','age':33}]


def sort_fn1(data): ##取出需要排序的元素(针对原始数据)

return data 


def sort_fn2(data): ##取出需要排序的元素(针对列表)

return data[1] 


def sort_fn3(data): ##取出需要排序的元素(针对字典)

return data['age'] 


##自己定义的排序函数

def my_sort(arr,sort_fn1):

for j in range(len(arr)-1):

for i in range(len(arr)-1):

if sort_fn1(arr[i]) >sort_fn1(arr[i+1]):

arr[i],arr[i+1]=arr[i+1],arr[i]

return arr


##对原始数据进行排序

print my_sort(arr,sort_fn1)


##对列表嵌套元组进行排序

print my_sort(arr2,sort_fn2)


##对列表嵌套字典进行排序

print my_sort(d,sort_fn3)



[r[root@xiaowei sorted]# python sort_fn.py 

##原始数据的排序结果

[0, 1, 2, 3, 6, 7, 14, 32, 65]


##列表嵌套元组的排序结果

[('xiaohua', 58), ('xiaohong', 90), ('xiaohei', 100)]


##列表嵌套字典的排序结果

[{'age': 10, 'name': 'xiaohei'}, {'age': 18, 'name': 'xiaohong'}, {'age': 33, 'name': 'xiaowang'}]

Noneoot@xiaowei sorted]#




7.4 最终大招--python自带的sorted()函数排序


    sorted()函数的格式如下：

     伪代码格式:    sorted(需要排序的列表,排序的元素)

     编码  格式:    sorted(arr,key=函数)


###使用python自带的sorted函数代码


##代码示例


[root@xiaowei sorted]# cat sorted.py

arr = [1,3,65,2,6,32,0,7,14]


def sort_fn1(data):

        return data

def sort_fn2(data):

        return data[1]

def sort_fn3(data):

        return data['age']

        

print sorted(arr,key=sort_fn1)


arr2 = [('xiaohong',90),('xiaohua',58),('xiaohei',100)]


print sorted(arr2,key=sort_fn2)


d = [{'name':'xiaohong','age':18},{'name':'xiaohei','age':10},{'name':'xiaowang','age':33}]


print sorted(d,key=sort_fn3)


##执行结果如下：

[root@xiaowei sorted]#

[root@xiaowei sorted]# python sorted.py 

[0, 1, 2, 3, 6, 7, 14, 32, 65]

[('xiaohua', 58), ('xiaohong', 90), ('xiaohei', 100)]

[{'age': 10, 'name': 'xiaohei'}, {'age': 18, 'name': 'xiaohong'}, {'age': 33, 'name': 'xiaowang'}]



7.5 python函数必备高阶技能之---lambda匿名函数


    lambda匿名函数的定义：特别简单的、没有名字的函数,仅有函数return返回值的函数。


###lambda函数举例


##lambda代码举例===>用于简写,简洁代码


In [13]: hello = lambda x:x

In [14]: print hello([1,2,3])

[1, 2, 3]


In [15]: hello = lambda x:x[2]

In [16]: print hello([1,2,3])

3


7.6 sorted()函数 + lambda匿名函数 终极通间易读实现排序


####思路就是将sorted()函数的key用lambda来定义

##代码举例

[root@xiaowei sorted]# cat ver.py 

arr = [1,3,2,78,21,32,55,0,9]


arr2 = [('xiaohong',90),('xiaohua',58),('xiaohei',100)]


d = [{'name':'xiaohong','age':18},{'name':'xiaohei','age':10},{'name':'xiaowang','age':33}]


print sorted(arr,key=lambda x:x)###使用lambda来获取排序的对象


print sorted(arr2,key=lambda x:x[1])###使用lambda来获取排序的对象


print sorted(d,key=lambda x:x['age'])###使用lambda来获取排序的对象


###排序结果展示

[root@xiaowei sorted]# python ver.py 

[0, 1, 2, 3, 9, 21, 32, 55, 78]


[('xiaohua', 58), ('xiaohong', 90), ('xiaohei', 100)]


[{'age': 10, 'name': 'xiaohei'}, {'age': 18, 'name': 'xiaohong'}, {'age': 33, 'name': 'xiaowang'}]


7.7 nginx日志处理的最终优化代码

  https://github.com/Fuliwei/newbie/blob/master/04/ketang/test.py(最终代码在辛苦移步github)


###统计nginx日志最终进阶：

##排序时使用sorted()+lambda以快速实现

###统计ip以及出现次数排序的代码优化

[root@xiaowei ketang]# cat test.py 

#/usr/bin/python

#coding:utf-8


def htmlStr(arr):

        html_str = "

/usr/local/src/newbie/04/ketang/test.py ====>result[test.html]

\n\n\n" %('Count','IP','URL')

        for i in arr:

                html_str += "

\n" %(i[1],i[0][0],i[0][1])


        html_str += "

%s%s%s
%s%s%s
\n"

        return html_str


def operateFile(filename,mode='r',string=''):

        if ('w' in mode) or ('a' in mode):

                with open(filename,'w') as files:

                        files.write(string)

                return 'Write OK'

        else:

                res = {}

                with open(filename) as files:

                        for line in files:

                                #print line 

                                line = line.strip('\n').split(' ')

                                #print line

                                tmp = (line[0],line[6])#,line[8])

                                res[tmp] = res.get(tmp,0)+1

                                #print "res is %s" %res

                        return sorted(res.items(),key=lambda x:x[1],reverse = True)


test = operateFile('log.log')

test = test[:10]

htmlstr = htmlStr(test)


print operateFile('/var/www/html/test.html',mode='w',string=htmlstr)



--end Thx.