|
申请会员ID: x75121 原创技术文章： 初识Python - python基础篇 由于本人是一名初学者，如果文章有不对的地方请麻烦大家帮我指出来!
一些简单概念： 字面常量，也就是我们所说的常量，在计算机中也就是一块内存。 变量：指向内存的一对符号。 文件系统：决定了文件的存放方式。 按位与: & 按位或： | 异或： ^ 列表： 列表：列表的复制为引用赋值，为浅拷贝，重新复制的时候id值是相同的，两者会同时修改，如果需要独立复制，则需要用切片方法来复制，为深度拷贝。列表相当于其他语言中的数组。 1、列表的基本概念： >>> f = [1, 2, 3, 9, 5] ###定义一个列表 >>> len(f) ###取列表的长度 5 >>> max(f) ###取列表的最大值 9 >>> min(f) ###取最小值 1 >>> 2 in f ###判断一个字符是否在列表中 True >>> del f[0] ###删除列表中的一个元素，按照列表的下标来删除 >>> f [2, 3, 9, 5] 2、列表的基本操作 >>> l=[1,2,3,4] >>> l [1, 2, 3, 4] >>> l.append('a') ###在列表后面追加一个元素 >>> l [1, 2, 3, 4, 'a'] >>> l.append([1,2,3]) ###在列表后面追加一个列表 >>> l [1, 2, 3, 4, 'a', [1, 2, 3]] >>> l.extend(['a','b',1,2,3]) ###将这个列表扩展到原来的列表中，并且打散 >>> l [1, 2, 3, 4, 'a', [1, 2, 3], 'a', 'b', 1, 2, 3] >>> f=['hello','world'] >>> f.extend(l) ###将l列表扩展到f列表中 >>> f ['hello', 'world', 1, 2, 3, 4, 'a', [1, 2, 3], 'a', 'b', 1, 2, 3] >>> l=[1,2,3,4] >>> l.insert(1,100) ###将100插入到下标为1的前面 >>> l [1, 100, 2, 3, 4] >>> l.insert(len(l),1000) ###将1000插入末尾 >>> l [1, 100, 2, 3, 4, 1000] >>> l.insert(1,[1,2,3,4]) ###在列表的下标为1的前面插入一个新的列表 >>> l [1, [1, 2, 3, 4], 100, 2, 3, 4, 1000] >>> l.remove(1000) ###从左向右删除这个值，一次只能删除一个 >>> l [1, [1, 2, 3, 4], 100, 2, 3, 4] >>> l.pop() ###从列表中最后的一个值先返回再删除，pop中加参数，代表删除下标对应的数值 4 >>> l [1, [1, 2, 3, 4], 100, 2, 3] >>> l [1, [1, 2, 3, 4], 100, 2, 3] >>> l.count(1) ###在列表中计算1出现的次数 1 [1, [1, 2, 3, 4], 100, 2, 3] >>> l.index(1) ###在列表中查找1所在的下标 0 >>> l.index(3) 4 >>> dir(l) ###查看l这个列表的变量 ['__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'] >>> l.reverse() ###反向输出列表 >>> l ['b', 'a', 5, 4, 3, 2, 1, 3, [1, 2, 3, 4], 5, 3, 4, 3, 2, 1] >>> l.sort() ###对列表进行排序 >>> l [1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, [1, 2, 3, 4], 'a', 'b'] ###########注意########### >>> p [1, 2, 6, 7, 8, 9, 9, 32, 43, 43, 90] >>> d=p >>> d [1, 2, 6, 7, 8, 9, 9, 32, 43, 43, 90] >>> d=p.sort() >>> d >>> type(d) ###此时的d为空，因为p.sort()函数无返回值，所以返回为空，所以d列表中为空 <type 'NoneType'> ######################### >>> l.insert(l.index(3),10) ###在一个值的前面插入一个元素 >>> l [1, 2, 10, 3, 4, 5] >>> l.insert(l.index(3)+1,10) ###在一个值的后面插入一个元素 >>> l [1, 2, 10, 3, 10, 4, 5] 切片：将列表中特定区间中的值输出 例如： list[1:10:1] ###起始点：结束点：步长 Python中直接拷贝，两个标签指向的内存在同一个位置，使用切片复制时，属于两个不同的内存 >>> k = l ###直接拷贝 >>> l [1, 2, 10, 3, 10, 4, 5] >>> k [1, 2, 10, 3, 10, 4, 5] >>> id(k) ###内存id号和原来的列表id号一致 42219640 >>> k = l[::] ###不加起点、终点、步长，代表从列表的第一位输出到列表的最后一位 >>> k [1, 2, 10, 3, 10, 4, 5] >>> l [1, 2, 10, 3, 10, 4, 5] >>> id(k) ###使用切片后，id号会变化 42222872 >>> id(l) 42219640 >>> l [1, 2, 10, 3, 10, 4, 5] >>> w = tuple(l) ###将一个列表直接转换成元组 >>> w (1, 2, 10, 3, 10, 4, 5) 列表解析：将列表中的数据进行循环运算，性能远远高于for循环 >>> li = [1,2,3] >>> li2 = [i+1 for i in li] ###将li列表中的每个元素+1，注意，表达式只能有一个，可以写成无 >>> li2 [2, 3, 4] >>> for i in li: ###上面的列表解析相当于这个for循环，但是效率比for循环的效率高 ... li3.append(i+1) ... >>> li3 [2, 3, 4] 列表解析和元组解析的区别： >>> li = [1,2,3,4] >>> li2 = [i+1 for i in li] ###列表解析，直接通过for循环生成目标列表 >>> li2 [2, 3, 4, 5] >>> li2 = (i+1 for i in li) ###元组解析，生成一个迭代器，每次需要的结果需要使用li2.next输出 >>> li2 <generator object <genexpr> at 0x27b8f00> >>> type(li2) <type 'generator'> >>> li2.next() ###主动的输出元组中的值， 2 >>> li2.next() 3 >>> li2.next() 4 >>> li2.next() 5 >>> li2.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration ###此处stop 带条件的列表解析：就是在列表解析中加入另外的条件 >>> li3 = [i+1 for i in li if i %2 == 0] ###将li列表中的偶数元素+1 >>> li3 [3] >>> id(li3) ###每个列表的id都不同 42219856 >>> id(li) 42219640 >>> li4 = [i for i in li if i % 2 == 0 if i > 5] ###if条件可以写多个，用多个条件对列表进行限制 >>> li4 [6, 8] 两个列表的笛卡尔积： >>> li4 = [(i,x) for i in li for x in li1] ###由于表达式只能有一个，所以用一个元组存放 >>> li4 [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)] 迭代器的性能远高于列表解析 元组： 元组：元组中的值不可更改，但是，在元组中加入列表的时候，此时列表中的值可修改 如果通过完全切片来复制，则两个元组的id号一致 集合： 集合：集合中的数据是无序排列的，并且是唯一的，并且会自动将hash值一致的数据进行合并，只有支持hash的数据才可放入集合中，集合不支持切片，声明一个空的集合：s = set() >>> s = {} ###默认定义为一个空字典 >>> type(s) <type 'dict'> >>> s = set() ###定义一个空集合 >>> type(s) <type 'set'> >>> s = {1,2,3,1,1,1,'1'} ###定义一个集合 >>> s set(['1', 1, 2, 3]) ###定义集合时，重复的符号只取其中一个 >>> s = {1,2,3,1,1,1,'1',[1,2,3]} ###列表不可被hash，所以不能加入集合 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list' >>> s = list(set([1,2,1,2,1,2,1,2])) ###可以使用集合对列表进行去重 >>> s [1, 2] >>> s set([1, 2, 3, 4]) >>> s.add(100) ###在集合中加入一个值，无序排列 >>> s set([1, 2, 3, 4, 100]) >>> s.update([200,300]) ###将一个列表更新到集合中，注意，不是加入 >>> s set([1, 2, 3, 4, 200, 300, 100]) >>> s.remove(100) ###删除集合中的一个值 >>> s set([1, 2, 3, 4, 200, 300]) >>> s.pop() ###随即删除集合中的一个值 1 >>> s set([2, 3, 4, 200, 300]) >>> s.discard('a') ###先在集合中查找这个值，如果没有，不做删除，否则删除 >>> s set([2, 3, 4, 200, 300]) >>> s1 = {1,2,3} >>> type(s1) <type 'set'> 集合中的运算： >>> s1.difference(s) ###取s1对s的差集 set([1]) >>> s.difference(s1) ###取s对s1的差集 set([200, 300, 4]) >>> s.difference_update(s1) ###求出差集后修改原值 >>> s set([1, 5]) >>> s - s1 ###做减运算，相当于差集 set([200, 300, 4]) >>> s1 - s set([1]) >>> s set([2, 3, 4, 200, 300]) >>> s1 set([1, 2, 3]) >>> s.intersection(s1) ###交集 set([2, 3]) >>> s1.intersection(s) set([2, 3]) set([1, 2, 3, 4, 5]) >>> s1 set([2, 3, 4]) >>> s.issubset(s1) ###子集，如果s1是s的子集，则返回True False >>> s1.issubset(s) True >>> s1.isdisjoint(s) ###如果两个集合没有共同的元素，则返回True，返回False，相当于intersection的负集 >>> s2.clear() ###清空一个集合 >>> s2.issuperset(s1) ###相当于issubset的负集 True >>> s1 set([2, 3, 4]) >>> s2 set([1, 2, 3, 4, 5]) >>> s set([1, 2, 4]) 字典： 字典：{key:value}，不能有重复的key，也就是说，key必须可hash，元组可作为key,列表不可以做为key，集合也不可用作key，迭代器的循环效率高于普通循环，字典不支持切片操作，但是支持copy >>> d.keys() ###以列表的形式返回key ['age', 'name', 'sex'] >>> d.values() ###以列表的形式返回values [23, 'tom', 'male'] >>> it = d.iterkeys() ###将字典中的key值定义为迭代器 >>> type(it) <type 'dictionary-keyiterator'> >>> it.next() ###主动请求迭代器中的数值 'age' >>> it.next() 'name' >>> it.next() 'sex' >>> it.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> d.items() ###将字典中的key:values用元组的形式成对输出 [('age', 23), ('name', 'tom'), ('sex', 'male')] >>> d.items() [('age', 23), ('name', 'tom'), ('sex', 'male')] >>> for i in d.values(): ###输出values ... print i ... 23 tom male >>> for i in d.keys(): ###输出keys ... print i,d ... age 23 name tom sex male >>> d.get('name') ###获取字典中key所对应的value 'tom' >>> d.get('eat',1111) ###获取字典中的key值时如果没有这个key值，则返回一个随机值 1111 >>> d['name'] 'tom' >>> d.has_key('name') ###可以用来判断key值是否存在 True >>> d['phone'] = 1111111 ###在字典中添加一个值，如果这个值已经存在，则进行修改 >>> d {'phone': 1111111, 'age': 23, 'name': 'tom', 'sex': 'male'} #################函数################## 函数定义：def func_name(): print ‘hello’ func_name() ###调用函数 变量：局部变量： 定义在函数内的变量，只能被函数本身调用，该变量为局部变量，当函数需要使用全局变量时，需要使用global 来调用全局变量，函数中存在一种延迟绑定 全局变量：定义在函数外部的变量，可以在全局中被调用 当函数名相同时，局部变量的优先级高于全局变量 1 #!/usr/bin/env python ###在linux系统中，该行为指定python的运行目录 2 #coding=utf-8 ###改行为指定使用字符集 3 4 def func_name(arg,arg1,arg2,arg3): #形式参数,作为局部变量 5 print arg,arg1,arg2,arg3 6 7 func_name(100,99,98,97) #实际参数,位置传参 8 func_name(arg3 =100,arg2 = 99,arg1 = 98,arg = 97) #关键字传参 9 10 def func_name1(arg1,arg2,arg3,arg=100): #带默认值的形式参数一定要定义在所有 不带默认值参数的后面 11 print arg,arg1,arg2,arg3 12 func_name1(2,3,4) 可变参数：（数量不一定），当参数传进来后，默认为一个元组，可以解决函数参数不够用的情况 1 #!/usr/bin/env python 2 #coding=utf8 3 def func_name(*arg): #可变参数传参 4 #arg is a tuple 5 print arg #参数的打包 6 7 li = [3,4,5,6,7] 8 func_name(*li) #相当于func_name(3,4,5,6,7) 9 10 li2 = ['a'] 11 12 func_name(*li2) #参数的解包 13 14 func_name(1,2) 15 #([3,4,5,6,7]) 例题： 1 #!/usr/bin/env python 2 #coding=utf8 3 4 def func_name(*arg): 5 host = arg[0] 6 port = arg[1] 7 username = arg[2] 8 passwd = arg[3] 9 db = None 10 if len(arg) == 5: 11 db = arg[4] 12 # if db is None default db is test 13 # if db is not None 14 15 func_name('127.0.0.1',3306,'root','123456') 可变位置传参： 关键字传参：和参数传递的顺序无关，但是在传参的时候必须指定好参数的位置. 1 #!/usr/bin/env python 2 #coding=utf8 3 4 def func_name(**kwarg): #可变位置参数 5 print kwarg 6 print kwarg['port'] 7 if kwarg.has_key('db'): 8 pass 9 else: 10 print 'db is not have' 11 #kwarg is a dict 12 13 func_name(host='127.0.0.1',port=3306,username='root') Python中所有的函数都是有返回值的，如果没有指定返回值，则默认返回值为None，可以返回多个值(相当于返回一个元组)，但是如果只有一个变量接收时，则该变量则接收一个元组。 #!/usr/bin/env python def func_re(x,y): return x+y,x*y b = func_re(1,3) ###此时一个变量接收两个返回值 a = list(func_re(1,3)) ###将返回值转换为一个列表 print a,b [4,3] (4, 3) ###输出为一个列表和元组 函数中尽量不要使用print，保持函数的纯洁性，不然会产生副作用，调试时可以加入print来调用 ##################递归算法##################### Python中最大的递归层数为999层，第1000层就会报错 1 #!/usr/bin/env python 2 #coding=utf8 3 #递归函数 4 #递归算法 5 def func_mul(n): 6 if n<=1: 7 return n 8 return func_mul(n-1)*n ###列表迭代算法 9 def func_mul2(n): 10 ret = 1 11 for x in range(n,1,-1): 12 ret = ret * x 13 return ret 14 a = func_mul(999) 15 print a 16 b = func_mul2(10) 17 print b ################函数传参################# 在定义函数时，可以将函数作为一个参数来进行重新定义，并且可以重新调用 1 #!/usr/bin/env python 2 #coding=utf8 3 4 def func_name(): 5 return 'test' 6 7 func = func_name #相当于将函数赋值给了func参数，两者的id时一致的，func可以> 调用函数 8 func1 = func_name() #相当于将函数的返回值赋值给func1 9 10 print func() #直接调用函数，可以返回'test' 11 print func1 12 def func(f): 13 print 'call func' 14 f(1,2) 15 16 def func2(x,y): 17 print 'call func2\n',x+y 18 19 func(func2) 输出结果： test test call func call func2 3
##########高阶函数############ filter()：filter(func,list) 过滤函数 >>> li [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> def f1(x): ... return x % 2 == 0 ###相当于将列表中的偶数过滤出来 ... >>> filter(f1,li) [2, 4, 6, 8] map() : map(func,list) 将列表中的所有元素都放在一个函数中执行一次，适用于hadoop,bigdata 如果一个服务器内存为8G，现在在一个10G大小的日志文件中查找出前10的IP 首先：需要将这个文件切割，由于文件太大，台占用内存，甚至于打不开该文件；比如切割成20份文件，先找到每份中前10，在将所以的前10放在一个文件中，然后再找前10 map ---->reduce MR 先分再总结，在进行切片的时候，可以使用awk命令 >>> li [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> def f2(x): ... return x*2 ... >>> map(f2,li) ###相当于对列表整体相乘2，扩大了一倍 [2, 4, 6, 8, 10, 12, 14, 16, 18] reduce() : reduce(func,list) 将列表中的前两个元素相操作的结果和第三个元素进行操作，再将操作结果与第四个元素进行操作，相当于进行一次阶乘，相当于一个总结的过程，报告生成器 >>> li [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> def f3(x,y): ... return x*y ... >>> reduce(f3,li) ###相当于对列表进行了一次阶乘 362880
|
吾爱游客
发表于 2016-6-8 11:53
