做打鱼网站犯法不,wordpress主题换字体,大数据营销的概念,国内新闻最新消息直接从六张开始看看书里有什么。 cmp() len() max() and min() sorted() and reversed() enumerate() and zip() sum() list() and tuple() dir()方法来得到它所有的方法和属性 extend() and append() extend()接受一个列表的内容#xff0c;然…直接从六张开始看看书里有什么。 cmp() len() max() and min() sorted() and reversed() enumerate() and zip() sum() list() and tuple() dir()方法来得到它所有的方法和属性 extend() and append() extend()接受一个列表的内容然后把所有元素追加到另一个列表中 append()把整个元素追加列表中如[].extend(abc) 最后输出的结果就是 [a, b, c] [].append(abc)输出结果是[abc] pop() 把数组中的元素去掉接受的参数是一个integer把传入的index去掉如果不传默认是最后一个range(start, end, step 1)filter(func, seq) map(func, seq1[,seq2...]) reduce(func, seq[, init])issubclass() isinstance() hasattr(), getattr(),setattr(), delattr() dir() super() vars() list.append(obj)list.count(obj)list.extend(seq) alist.index(obj, i0,jlen(list))list.insert(index, obj) list.pop(index-1)list.remove(obj)list.reverse()list.sort(funcNone,keyNone,reverseFalse) 字典 d {name:allen,name2:allen,age:40}d dict(([x, 1],[y, 2], [z,3])) # 注意两个()dict只接受一个参数可以是元祖可以是列表每个组合的数据个数两个d dict([[x, 1],[y, 2], [z,3]])d {}.fromkeys((x, y), 1)d dict(zip((x, y), (1, 2)))d dict([(xy[i-1], i) for i in range(1,3)]) #{y:2, x:1}d dict(x1, y2)cmp():字典的比较先比较两个字典的元素个数通过keys()方法获取返回键的顺序在比较第一组的键在比较第一组的值在比较第二组的键。。。。。。。。 dict.clear ()dict.copy ()dict.fromkeys (seq, valNone) cdict.get(key,defaultNone)dict.has_key(key)dict.items()dict.keys()dict.iter() 对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此键,则返回 default 的值(注意,参数 default 的默认值为 None)dict.pop (key[, default]) dict.setdefault(key,defaultNone) dict.update(dict2) 将字典 dict2 的键-值对添加到字典 dictdict.values() set() frozenset()集合等价/不等价 obj in sobj not in s s t s ! t s t (严格意义上)子集测试; s ! t 而且s中所有的元素都是 t 的成员s.issubset(t) s t s ts.issubset(t) s t s ts.issuperset(t) s ts.union(t) s | t 合并操作:s 或 t 中的元素s.intersection(t) s t 交集操作:s 和 t 中的元素s.difference(t) s - t 差分操作: s 中的元素,而不是 t 中的元素s.symmetric_difference(t) s ^ t 对称差分操作:s 或 t 中的元素,但不是 s 和 t 共有的元素s.update(t) s | t (Union) 修改操作: 将 t 中的成员添加 ss.intersection_update(t) s t 交集修改操作: s 中仅包括 s 和 t 中共有的成员s.difference_update(t) s - t 差修改操作: s 中包括仅属于 s 但不属于 t 的成员s.symmetric_difference_update(t) s ^ t 对称差分修改操作: s 中包括仅属于 s 或仅属于 t 的成员s.add(obj)s.remove(obj)s.discard(obj)s.pop()s.clear() 条件和循环 if condition: passelif condition: passelse: pass while expression: pass for iter_var in iterable: pass pass什么也不做 文件和输入输出 open() file()file_object open(file_name, access_moder, buffering-1)access_mode是一个字符串代表一个文件打开的模式r读 w写 a追加 U通用换行符。r 和U 打开的文件必须是存在的w打开的文件首先会清空a打开的文件是为了追加做准备的所有写入的文件追加到末尾。 代表可读可写b 代表二进制模式访问buffering用于指示访问文件采用的缓冲方式0 表示不缓冲1 表示只缓冲一行数据。 r 以读方式打开rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)w 以写方式打开 (必要时清空)a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)r 以读写模式打开w 以读写模式打开 (参见 w )a 以读写模式打开 (参见 a )rb 以二进制读模式打开wb 以二进制写模式打开 (参见 w )ab 以二进制追加模式打开 (参见 a )rb 以二进制读写模式打开 (参见 r )wb 以二进制读写模式打开 (参见 w )ab 以二进制读写模式打开 (参见 a )例子fp open(rc:\io.sys, rb) # 以二进制读模式打开 这里需要说一下的是file_name参数中的r 的意思是名字就是字符串的所显示的名也就是遇见 ’\‘ 不转义 open() open() 和 file() 函数具有相同的功能, 可以任意替换.您所看到任何使用 open() 的地方, 都可以使用 file() 替换它.一般说来, 我们建议使用 open() 来读写文件, 在您想说明您在处理文件对象时使用 file() , 例如 ifinstance(f, file) 9.2.2 通用换行符支持(UNS) 不同平台用来表示行结束的符号是不同的, 例如 \n, \r, 或者 \r\n这就是 UNS 的关键所在, 作为 PEP 278 的结果, Python 2.3 引入了 UNS. 当你使用 U 标志打开文件的时候, 所有的行分割符(或行结束符, 无论它原来是什么)通过 Python 的输入方法(例如 read*() )返回时都会被替换为换行符 NEWLINE(\n). (rU 模式也支持 rb 选项) . 这个特性还支持包含不同类型行结束符的文件. 文件对象的 newlines 属性会记录它曾“看到的”文件的行结束符. 如果文件刚被打开, 程序还没有遇到行结束符, 那么文件的 newlines 为 None .在第一行被读取后, 它被设置为第一行的结束符. 如果遇到其它类型的行结束符, 文件的 newlines 会成为一个包含每种格式的元组. 注意 UNS 只用于读取文本文件. 没有对应的处理文件输出的方法.在编译 Python 的时候,UNS 默认是打开的. 如果你不需要这个特性, 在运行 configure 脚本时,你可以使用 --without-universal-newlines 开关关闭它. 如果你非要自己处理行结束符, 请查阅核心笔记,使用 os 模块的相关属性. 当使用输入方法如 read() 或者 readlines() 从文件中读取行时, Python 并不会删除行结束符. 这个操作被留给了程序员. 例如这样的代码在 Python 程序中很常见:f open(myFile, r)data [line.strip() for line in f.readlines()]f.close()类似地, 输出方法 write() 或 ritelines() 也不会自动加入行结束符. 你应该在向文件写入数据前自己完成。 文件内移动seek() seek() 方法(类似 C 中的 fseek() 函数)可以在文件中移动文件指针到不同的位置. offset字节代表相对于某个位置偏移量. 位置的默认值为 0 , 代表从文件开头算起(即绝对偏移量), 1 代表从当前位置算起, 2 代表从文件末尾算起. 如果你是一个 C 程序员,并且使用过了 fseek() , 那么,0, 1, 2 分别对应着常量 SEEK_SET, SEEK_CUR, 以及 SEEK_END. 当人们打开文件进行读写操作的时候就会接触到 seek()方法。 text() 方法是对 seek() 的补充; 它告诉你当前文件指针在文件中的位置 - 从文件起始算起,单位为字节.seek()方法在文件内移动tell()告诉我们当前的位置。 函数一个方法理解可变长度的函数只有是 * * 格式的才会进入**dict_args中否则就算本身是dict也算入*tuple_args中 def bar1(arg1, arg2default, *tuple_args, **dict_args):print arg1: , arg1print arg2: , arg2 for i in tuple_args:print tuple_args: , ifor j in dict_args.keys():print dict_args : %s %s % (j, dict_args[j])
d dict(x1, y2)
bar1(1, 2, 3, 4, d, d, x1, y1) 结果arg1: 1
arg2: 2
tuple_args: 3
tuple_args: 4
tuple_args: d
tuple_args: {y: 2, x: 1}
dict_args : y 1
dict_args : x 1 匿名函数lambda a lambda x, y 2: x y filter函数用法 就是过滤用的经过帅选选出符合方法返回值的数。传入的方法有且只接受一个参数 def odd(n):return n % 2
allNums range(10)
print filter(odd, allNums)结果[1, 3, 5, 7, 9] map函数用法 print map(lambda x, y: (xy, x-y), [1,3,5], [2,4,6])
结果[(3, -1), (7, -1), (11, -1)] reduce函数用法就是算出前两个参数的值作为一个值和第三个参数一起算出一个值依次进行。 def add(x, y):return x y
print reduce(add, [1,2,3])结果6 partial函数的用法int函数的用法:int(10)省略了base10默认就是一个十进制的数所以用int(10)也可已得到十进制数。int(11, base 2)会得到一个基于二进制的十位数这里的不痛是指定了base参数那么前面的参数就必须是一个string类型的参数int(11, base2)会报 : int() cant convert non-string with explicit base baseTwo partial(int, base2)
baseTwo(10010)结果18下面这种写法baseTwoBAD partial(int, 2)baseTwoBAD(10010) TypeError: an integer is requiredbaseTwoBAD(10) TypeError: int() cant convert non-string with explicit base 上面baseTwo(x) int(x, base2)。baseTwoBAD(x) int(2, x)关键字参数总是出现在形参之后也就是说a * 这种关键字参数一定要出现在单独一个参数 x 后面这里没有指定base2默认为形参当在传入x后x会放在第二个位置上也就是base的位置所以上面两种情况分别报了不同错误。 作用域变量是有作用域的在方法中声明的变量虽然和全局变量名一样也有可能直接访问全局变量但是出了方法后全局变量的值就变回来了。直接代码解释 g_str fzk
def test1():print g_str 没有问题结果fzk g_str fzk
def test1():print g_strg_str badboyprint g_str 报错UnboundLocalError: local variable g_str referenced before assignment。 g_str fzk
def test1():print g_strg_str badboyprint g_strglobal g_strprint g_str结果 fzk badboy badboy 第三种情况没报错说明全部变量global在哪里声明都无所谓只要在方法里声明了。 闭包的问题是一个问题和装饰器弄一篇。 在导入模块的时候注意循环导入的问题。 python中一个模块也就是一个已.py结尾的文件 一个packge中可以有很多个模块一般新建一个packge后会自动生成一个__init__.py文件。 类中的__init__(), __new()__, __del__()__init__() 就是一个构造器一般自己重写。__new__()这个方法更像是一个构造器因为__new()__必须返回一个合法的实例这样解释器在调用__init__()时就可以把他作为self传给他。调用__new()__会先调用父类的__new()__。__del__() 结构器只有在所有的引用全部del后才会调用__del__()方法。调用__del__()方法前先调用父类的__del__()方法。并不是调用删除一个属性(del a)就会调用这个方法这是删除了一个引用只有全部引用全部删除后才会调用这个方法。 类中有属性修改实例中的类属性时需要谨慎。实例中可以访问类中的属性类中的属性修改实例也会感知到。但是如果在实例中修改类的属性就要注意了如果实例中修改类的属性相当于在实例中创建了原类中相同名的一个属性(只是名一样并不是类中的属性)实例在访问自己的属性时先会查找自己的属性没有则会从类中查找如果修改了实例中属性相当于给实例属性赋值这时就不会从类中查找除非删除实例中属性。 class B(object):foo 1passb2 B()print B.fooprint b2.foob2.foo 3print b2.fooprint B.foob3 B()print b3.fooB.foo 4print B.fooprint b2.fooprint b3.foo结果 1 1 3 1 1 4 3 4 classmethod和staticmethod class C(object):def foo():passfoo staticmethod(foo) staticmethod def bar(): passclass D(object):def foo(cls):pass classmethod def bar(): passfoo classmethod(foo) 对应的内建函数被转换成它们相应的类型,并且重新赋值给了相同的变量名。如果没有调用这两个函数,二者都会在 Python 编译器中产生错误,显示需要带 self 的常规方法声明。现在, 我们可以通过类或者实例调用这些函数。没个类中两个的方法的生命是等价的。 老式类和新式类集成的问题 老实类采用深度优先比如 class P1: #(object): def foo(self):print called P1-foo()
class P2: #(object)def foo(self):print called P2-foo() def bar(self):print called P2-bar()
class C1(P1, P2): pass
class C2(P1, P2): def bar(self):print called C2-bar()
class GC(C1, C2):pass gc GC()
gc.foo() # GC C1 P1
called P1-foo()
gc.bar() # GC C1 P1 P2
called P2-bar() 新式类采用广度优先 上面的代码中把p1和p2的(object)注解打开。重新调用上面的两个方法 gc GC()
gc.foo()# GC C1 C2 P1
called P1-foo()
gc.bar() # GC C1 C2
called C2-bar() 在继承类的括号中如C1(P1, P2)左边p1右边p2从左侧开始查找查找完一个类后在找同胞顺序是从左到右依次向深处查找。直到找到为止。下面还有一个例子 class G(object):def __init__(self):print G init
class H(object):def __init__(self):print H init
class I( H, G):pass
i I() 结果H init 如果改成下面这样 class I(G, H):pass 结果G init 定制类基本定制型 C.__init__(self[, arg1, ...]) 构造器(带一些可选的参数)C.__new__(self[, arg1, ...]) 构造器(带一些可选的参数);通常用在设置不变数据类型的子类。C.__del__(self) 解构器C.__str__(self) 可打印的字符输出;内建 str()及 print 语句C.__repr__(self) 运行时的字符串输出;内建 repr() 和‘‘ 操作符C.__unicode__(self) Unicode 字符串输出;内建 unicode()C.__call__(self, *args) 表示可调用的实例C.__nonzero__(self) 为 object 定义 False 值;内建 bool() (从 2.2 版开始)C.__len__(self) “长度”(可用于类);内建 len() 特殊方法C.__cmp__(self, obj) 对象(值)比较对象比较;内建 cmp()C.__lt__(self, obj) and 小于/小于或等于;对应及操作符C.__gt__(self, obj) and 大于/大于或等于;对应及操作符C.__eq__(self, obj) and 等于/不等于;对应,!及操作符 属性C.__getattr__(self, attr) 获取属性;内建 getattr();仅当属性没有找到时调用C.__setattr__(self, attr, val) 设置属性C.__delattr__(self, attr) 删除属性C.__getattribute__(self, attr) 获取属性;内建 getattr();总是被调用C.__get__(self, attr) (描述符)获取属性C.__set__(self, attr, val) (描述符)设置属性C.__delete__(self, attr) (描述符)删除属性 数值类型:二进制操作符C.__*add__(self, obj) 加;操作符C.__*sub__(self, obj) 减;-操作符C.__*mul__(self, obj) 乘;*操作符C.__*div__(self, obj) 除;/操作符C.__*truediv__(self, obj) True 除;/操作符C.__*floordiv__(self, obj) Floor 除;//操作符C.__*mod__(self, obj) 取模/取余;%操作符C.__*divmod__(self, obj) 除和取模;内建 divmod()C.__*pow__(self, obj[, mod]) 乘幂;内建 pow();**操作符C.__*lshift__(self, obj) 左移位;操作符 定制类/模拟类型数值类型:二进制操作符 C.__*rshift__(self, obj) 右移;操作符C.__*and__(self, obj) 按位与;操作符C.__*or__(self, obj) 按位或;|操作符C.__*xor__(self, obj) 按位与或;^操作符数值类型:一元操作符 C.__neg__(self) 一元负C.__pos__(self) 一元正C.__abs__(self) 绝对值;内建 abs()C.__invert__(self) 按位求反;~操作符数值类型:数值转换 C.__complex__(self, com) 转为 complex(复数);内建 complex()C.__int__(self) 转为 int;内建 int()C.__long__(self) 转为 long;内建 long()C.__float__(self) 转为 float;内建 float()数值类型:基本表示法(String)C.__oct__(self) 八进制表示;内建 oct()C.__hex__(self) 十六进制表示;内建 hex()数值类型:数值压缩C.__coerce__(self, num) 压缩成同样的数值类型;内建 coerce()C.__index__(self) 在有必要时,压缩可选的数值类型为整型(比如:用于切片索引等等) 序列类型C.__len__(self) 序列中项的数目C.__getitem__(self, ind) 得到单个序列元素C.__setitem__(self, ind,val) 设置单个序列元素C.__delitem__(self, ind) 删除单个序列元素 特殊方法序列类型C.__getslice__(self, ind1,ind2) 得到序列片断C.__setslice__(self, i1, i2,val) 设置序列片断C.__delslice__(self, ind1,ind2) 删除序列片断C.__contains__(self, val) 测试序列成员;内建 in 关键字C.__*add__(self,obj) 串连;操作符C.__*mul__(self,obj) 重复;*操作符C.__iter__(self) 创建迭代类;内建 iter() 映射类型C.__len__(self) mapping 中的项的数目C.__hash__(self) 散列(hash)函数值C.__getitem__(self,key) 得到给定键(key)的值C.__setitem__(self,key,val) 设置给定键(key)的值C.__delitem__(self,key) 删除给定键(key)的值C.__missing__(self,key) 给定键如果不存在字典中,则提供一个默认值 * 代表(selp OP obj), r(obj OP self),或i(原位(in-place)操作),例如__add__, __radd__, or __iadd__. 双下划线(__)和单下划线(_)双下划线是Python 为类元素(属性和方法)的私有性提供的形式。单下划线是模块级私有化。可以防止模块的属性用“from module import *”来加载。 __slots__属性 __dict__属性跟踪所有实例属性。举例来说,你有一个实例 inst.它有一个属性 foo,那使用 inst.foo 来访问它与使用 inst.__dict__[foo]来访问是一致的。字典会占据大量内存,如果你有一个属性数量很少的类,但有很多实例,那么正好是这种情况。为内存上的考虑,用户现在可以使用__slots__属性来替代__dict__。如果__slots__属性中没有要获取的属性户会报异常如果在__slots__外面又定义了一个属性a那么a是read-only的。 class SlottedClass(object):__slots__ (foo, bar)
c SlottedClass()
c.xxx dont think so结果AttributeError: SlottedClass object has no attribute xxx 要知道的是他继承的是object如果继承了其他的类但是这个类中并没有用__slots__属性那么也不会报错他会认为那个属性是父类的。但是如果父类非object也用了__slots__那么和集成object效果一样。 描述符真的是一个很恶心的东西。在弄一篇。 callable()一个布尔函数确定一个对象是否可以通过函数操作符(())来调用。如果函数可调用便返回 True,否则便是 False compile()函数允许程序员在运行时刻迅速生成代码对象函数中有三个参数都是必须的第一个参数是python代码。第二个是一个字符串存放代码生成文件的名字通常置为空(‘’)。第三个参数有三个选择 eval 可求值的表达式[和 eval()一起使用] single 单一可执行语句[和 exec 一起使用] exec 可执行语句组[和 exec 一起使用] eval_code compile(100 200, , eval)
eval(eval_code)single_code compile(print Hello world!, , single)
single_codeexec_code compile(
... req input(Count how many numbers? )
... for eachNum in range(req):
... print eachNum
... , , exec)
exec exec_code eval()对表达式求值。如eval(100 200) exec exec x 0print x is currently:, xwhile x 5:x 1print incrementing x to:, x input()是 eval()和 raw_input()的组合,等价于 eval(raw_input())。如aList input(Enter a list: )转载于:https://www.cnblogs.com/badboyf/p/6111425.html
