申请会员ID：x75121
申请会员ID: x75121个人邮箱：7792644@qq.com原创技术文章：初识Python- python基础篇由于本人是一名初学者，如果文章有不对的地方请麻烦大家帮我指出来!一些简单概念：字面常量，也就是我们所说的常量，在计算机中也就是一块内存。变量：指向内存的一对符号。文件系统：决定了文件的存放方式。按位与: &按位或：|异或： ^ 列表：列表：列表的复制为引用赋值，为浅拷贝，重新复制的时候id值是相同的，两者会同时修改，如果需要独立复制，则需要用切片方法来复制，为深度拷贝。列表相当于其他语言中的数组。1、列表的基本概念：>>> f = ###定义一个列表>>> len(f) ###取列表的长度5>>> max(f) ###取列表的最大值9>>> min(f) ###取最小值1>>> 2 in f ###判断一个字符是否在列表中True >>> del f ###删除列表中的一个元素，按照列表的下标来删除>>> f2、列表的基本操作>>> l=>>> l>>> l.append('a') ###在列表后面追加一个元素>>> l>>> l.append() ###在列表后面追加一个列表>>> l]>>> l.extend(['a','b',1,2,3]) ###将这个列表扩展到原来的列表中，并且打散>>> l, 'a', 'b', 1, 2, 3]>>> f=['hello','world']>>> f.extend(l) ###将l列表扩展到f列表中>>> f['hello', 'world', 1, 2, 3, 4, 'a', , 'a', 'b', 1, 2, 3]>>> l=>>> l.insert(1,100) ###将100插入到下标为1的前面>>> l>>> l.insert(len(l),1000) ###将1000插入末尾>>> l>>> l.insert(1,) ###在列表的下标为1的前面插入一个新的列表>>> l, 100, 2, 3, 4, 1000]>>> l.remove(1000) ###从左向右删除这个值，一次只能删除一个>>> l, 100, 2, 3, 4]>>> l.pop() ###从列表中最后的一个值先返回再删除，pop中加参数，代表删除下标对应的数值4>>> l, 100, 2, 3]>>> l, 100, 2, 3]>>> l.count(1) ###在列表中计算1出现的次数1, 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, , 5, 3, 4, 3, 2, 1]>>> l.sort() ###对列表进行排序>>> l, 'a', 'b']###########注意###########>>> p>>> d=p>>> d>>> d=p.sort()>>> d>>> type(d) ###此时的d为空，因为p.sort()函数无返回值，所以返回为空，所以d列表中为空<type 'NoneType'>#########################>>> l.insert(l.index(3),10) ###在一个值的前面插入一个元素>>> l>>> l.insert(l.index(3)+1,10) ###在一个值的后面插入一个元素>>> l 切片：将列表中特定区间中的值输出 例如：list ###起始点：结束点：步长Python中直接拷贝，两个标签指向的内存在同一个位置，使用切片复制时，属于两个不同的内存>>> k = l ###直接拷贝>>> l>>> k>>> id(k) ###内存id号和原来的列表id号一致42219640>>> k = l[::] ###不加起点、终点、步长，代表从列表的第一位输出到列表的最后一位>>> k>>> l>>> id(k) ###使用切片后，id号会变化42222872>>> id(l)42219640>>> l>>> w = tuple(l) ###将一个列表直接转换成元组>>> w(1, 2, 10, 3, 10, 4, 5) 列表解析：将列表中的数据进行循环运算，性能远远高于for循环>>> li = >>> li2 = ###将li列表中的每个元素+1，注意，表达式只能有一个，可以写成无>>> li2>>> for i in li: ###上面的列表解析相当于这个for循环，但是效率比for循环的效率高...li3.append(i+1)...>>> li3 列表解析和元组解析的区别：>>> li = >>> li2 = ###列表解析，直接通过for循环生成目标列表>>> li2>>> 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 = ###将li列表中的偶数元素+1>>> li3>>> id(li3) ###每个列表的id都不同42219856>>> id(li)42219640 >>> li4 = ###if条件可以写多个，用多个条件对列表进行限制>>> li4 两个列表的笛卡尔积：>>> 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'} ###定义一个集合>>> sset(['1', 1, 2, 3]) ###定义集合时，重复的符号只取其中一个>>> s = {1,2,3,1,1,1,'1',} ###列表不可被hash，所以不能加入集合Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: unhashable type: 'list'>>> s = list(set()) ###可以使用集合对列表进行去重>>> s>>> sset()>>> s.add(100) ###在集合中加入一个值，无序排列>>> sset()>>> s.update() ###将一个列表更新到集合中，注意，不是加入>>> sset()>>> s.remove(100) ###删除集合中的一个值>>> sset()>>> s.pop() ###随即删除集合中的一个值1>>> sset()>>> s.discard('a') ###先在集合中查找这个值，如果没有，不做删除，否则删除>>> sset() >>> s1 = {1,2,3}>>> type(s1)<type 'set'> 集合中的运算：>>> s1.difference(s) ###取s1对s的差集set()>>> s.difference(s1) ###取s对s1的差集set()>>> s.difference_update(s1) ###求出差集后修改原值>>> sset()>>> s - s1 ###做减运算，相当于差集set()>>> s1 - sset()>>> sset()>>> s1set() >>> s.intersection(s1) ###交集set()>>> s1.intersection(s)set()set() >>> s1set()>>> s.issubset(s1) ###子集，如果s1是s的子集，则返回TrueFalse>>> s1.issubset(s) True>>> s1.isdisjoint(s) ###如果两个集合没有共同的元素，则返回True，返回False，相当于intersection的负集>>> s2.clear() ###清空一个集合>>> s2.issuperset(s1) ###相当于issubset的负集True>>> s1set()>>> s2set()>>> sset() 字典：字典：{key:value}，不能有重复的key，也就是说，key必须可hash，元组可作为key,列表不可以做为key，集合也不可用作key，迭代器的循环效率高于普通循环，字典不支持切片操作，但是支持copy >>> d.keys() ###以列表的形式返回key['age', 'name', 'sex']>>> d.values() ###以列表的形式返回values >>> 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...23tommale>>> for i in d.keys(): ###输出keys... print i,d...age 23name tomsex 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'} #################函数##################函数定义：deffunc_name():print‘hello’func_name() ###调用函数变量：局部变量： 定义在函数内的变量，只能被函数本身调用，该变量为局部变量，当函数需要使用全局变量时，需要使用global 来调用全局变量，函数中存在一种延迟绑定 全局变量：定义在函数外部的变量，可以在全局中被调用当函数名相同时，局部变量的优先级高于全局变量1 #!/usr/bin/env python ###在linux系统中，该行为指定python的运行目录2 #coding=utf-8 ###改行为指定使用字符集34 def func_name(arg,arg1,arg2,arg3):#形式参数,作为局部变量5 printarg,arg1,arg2,arg367 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 printarg,arg1,arg2,arg3 12 func_name1(2,3,4) 可变参数：（数量不一定），当参数传进来后，默认为一个元组，可以解决函数参数不够用的情况1 #!/usr/bin/env python2 #coding=utf83 def func_name(*arg): #可变参数传参4 #arg is a tuple5 print arg #参数的打包67 li = 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 #()例题：1 #!/usr/bin/env python2 #coding=utf834 def func_name(*arg):5 host = arg6 port = arg7 username = arg8 passwd = arg9 db = None 10 if len(arg) == 5: 11 db = arg 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 python2 #coding=utf834 def func_name(**kwarg): #可变位置参数5 print kwarg6 print kwarg['port']7 if kwarg.has_key('db'):8 pass9 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) ###输出为一个列表和元组函数中尽量不要使用print，保持函数的纯洁性，不然会产生副作用，调试时可以加入print来调用 ##################递归算法#####################Python中最大的递归层数为999层，第1000层就会报错1 #!/usr/bin/env python2 #coding=utf83 #递归函数4 #递归算法5 def func_mul(n):6 if n<=1:7 return n8 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 python2 #coding=utf834 def func_name():5 return 'test'67 func = func_name#相当于将函数赋值给了func参数，两者的id时一致的，func可以> 调用函数8 func1 = func_name()#相当于将函数的返回值赋值给func19 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)输出结果：testtestcall funccall func23
##########高阶函数############filter()：filter(func,list) 过滤函数>>> li>>> def f1(x):... return x % 2 == 0 ###相当于将列表中的偶数过滤出来...>>> filter(f1,li) map() : map(func,list) 将列表中的所有元素都放在一个函数中执行一次，适用于hadoop,bigdata 如果一个服务器内存为8G，现在在一个10G大小的日志文件中查找出前10的IP首先：需要将这个文件切割，由于文件太大，台占用内存，甚至于打不开该文件；比如切割成20份文件，先找到每份中前10，在将所以的前10放在一个文件中，然后再找前10map ---->reduceMR 先分再总结，在进行切片的时候，可以使用awk命令>>> li>>> def f2(x):... return x*2...>>> map(f2,li) ###相当于对列表整体相乘2，扩大了一倍 reduce() : reduce(func,list)将列表中的前两个元素相操作的结果和第三个元素进行操作，再将操作结果与第四个元素进行操作，相当于进行一次阶乘，相当于一个总结的过程，报告生成器>>> li>>> def f3(x,y):... return x*y...>>> reduce(f3,li) ###相当于对列表进行了一次阶乘362880
抱歉，未能达到申请要求，申请不通过，可以关注论坛官方微信（吾爱破解论坛），等待开放注册通知。
页:
[1]