您好,欢迎访问本站博客!
  • 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧
  • 网站所有资源均来自网络,如有侵权请联系站长删除!

伊沙贝拉互联网+周末分享-互联网加班

全部文章 admin 2014-08-06 56 次浏览
互联网+周末分享-互联网加班
吉祥
新年快乐Happy new year!新年快乐金陵船厂 !元旦快乐!我们会互道新年快乐这一天,大家互相祝福,互赠贺卡,表达美好的愿景因此元旦在中国也被称为“新历年”“阳历年”中华人民共和国成立时得以明确中华民国始为公历1月1日汉武帝始为农历1月1日,并延用中国古代曾以腊月、十月等的月首为元旦元旦快乐!

Python

运算符优先级
在一个表达式中,Python会首先计算下表中较下面的运算符,然后在计算列在下表上部的运算符。
在下表中列在同一行的运算符具有 相同优先级 。例如,+和-有相同的优先级。
建议使用圆括号来分组运算符和操作数,以便能够明确地指出运算的先后顺序,使程序尽可能地易读。例如,2 + (3 * 4)显然比2 + 3 * 4清晰。
运算符 描述
lambda Lambda表达式
or 布尔“或”
and 布尔“与”
not x布尔“非”
in,not in 成员测试
is,is not 同一性测
<,<=,>,>=,!=,==比较
|按位或
^ 按位异或
& 按位与
<<,>>移位
+,- 加法与减法
*,/,% 乘法、除法与取余
+x,-x正负号
~x 按位翻转
** 指数
x.attribute 属性参考
x[index]下标
x[index:index] 寻址段
f(arguments...) 函数调用
(experession,...)绑定或元组显示
[expression,...] 列表显示
{key:datum,...} 字典显示
'expression,...' 字符串转换


控制流
if 语句
写法: if ... elif ... else ... # if后面不用圆括号
注:在Python中没有switch语句石猛。你可以使用 if..elif..else 语句来完成同样的工作(在某些场合,使用字典会更加快捷。)
在C/C++里面可以使用 else if ,但这里不行,得写成: else : if,故此增加关键字 elif
例:
number = 23
# int是一个类武林三国 ,不过这里它只是把一个字符串转换为一个整数(假设这个字符串含有一个有效的整数文本信息)。
guess = int(raw_input('输入一个整数“))
if guess == number:
print('非常好')
elif guess < number:
print('小了')
# 另一种表示
else:
print('大了')
while 语句
只要条件为真,while语句允许你重复执行一块语句。
注:while语句有一个可选的else从句。else块事实上是多余的,因为可以把其中的语句跟在while语句里面。
例:
number = 23
running = True
while running:
guess = int(raw_input('输入一个整数“))
if guess == number:
print('非常好')
running = False # 此时结束循环
elif guess < number:
print('小了‘)
else:
print('大了')
else:
# 循环结束后的语句
print('while到此结束.')
for 循环
for..in 是另外一个循环语句,它在一序列的对象上 递归 即逐一使用队列中的每个项目。
else 部分是可选的。如果包含 else,它总是在 for 循环结束后执行一次,除非遇到 break 语句。
例:
for i in range(1, 5):
print(i)
else:
print('for到此结束')
# 打印结果: 1 至 4 以及 else 的内容
# range(1段黄巍 ,5)给出序列[1, 2, 3, 4]。range默认步长为1,第三个参数是步长。比如,range(1,5,2)给出[1,3]。就可以看做是跳过(步长-1)个输出一次。如果是负数,则是反向减去,比如range(10, 1, -2),输出[10, 8, 6, 4,2]
# 记住,range包含第一个数,但不包含第二个数。
注:
Python的 for 循环从根本上不同于C/C++的 for 循环。类似 foreach 循环。
在C/C++中,如果你想要写 for (int i = 0; i < 5; i++),那么用Python,你写成 for i in range(0,5)。
# 范例:九九乘法表
# 由于Python2 与Python3的 print 语法不相同,改用string来打印,
str = ''
for i in range(1,10):
for j in range(1, i+1):
str += ('%d * %d = %d ' % (j, i, i*j))
str += ' '
print(str)
break 语句
break 语句是用来 终止 循环语句的,即哪怕循环条件没有称为 False 或序列还没有被完全递归,也停止执行循环语句。
一个重要的注释是,如果你从 for 或 while 循环中 终止 ,任何对应的循环 else 块将不执行。
continue 语句
continue 语句被用来告诉Python跳过当前循环块中的剩余语句,然后 继续 进行下一轮循环。
break 语句 和 continue 语句 对于 while 循环 和 for 循环 都有效。
while True:
s = input('Enter something : ') # 3.x用input()代替raw_input(),且会获取结尾输入的换行符
s = s[:-1] # 去掉结尾的换行符
if s == 'good':
break
if len(s) < 3:
continue
print('s的总长度为', len(s))


对象
Python 将 "一切皆对象" 贯彻得非常彻底,不区分什么 "值类型" 和 "引用类型"。所谓变量,实质就是一个通用类型指针 (PyObject*),它仅仅负责指路,至于目标是谁,一概不管。
Python Object 对象的自身结构了。任何对象,就算一个最简单的整数,它的头部都会拥有 2 个特殊的附加信息,分别是:"引用计数" 和 "类型 (type) 指针" 。前者指示 GC 何时回收,而后者标明了对象的身份,如此我们就可以在运行期动态执行对象成员调用。


《面向对象的编程》
面向过程的编程:根据操作数据的函数或语句块来设计程序的。
面向对象的编程:把数据和功能结合起来,用称为对象的东西包裹起来组织程序的方法。
类和对象是面向对象编程的两个主要方面。“类”创建一个新类型,而“对象”是这个类的实例。
域:属于一个对象或类的变量王翊丹。
方法:属于类的函数,被称为类的方法。
域和方法可以合称为类的属性。
域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。
类使用class关键字创建。类的域和方法被列在一个缩进块中。
self 参数
类的方法与普通的函数只有一个特别的区别——它们“必须”有一个额外的第一个参数名称,但是在调用这个方法的时候你不为这个参数赋值,Python会提供这个值。这个特别的变量指对象本身,按照惯例它的名称是self。
虽然你可以给这个参数任何名称,但是“强烈建议”使用self这个名称——其他名称都是不赞成使用的。
使用一个标准的名称有很多优点——1.方便别人阅读;2.有些IDE(集成开发环境)也可以帮助你。
Python中的self等价于C++中的self指针和Java、C#中的this参考。
例:
class Person:
def sayHi(self): # self参数必须写
print('Hello, how are you?')
p = Person()
p.sayHi() # self参数不需赋值
print(p) # 打印: <__main__.Person instance at 0xf6fcb18c> (已经在__main__模块中有了一个Person类的实例)
类的变量和对象的变量
类的变量: 由一个类的所有对象(实例)共享使用吴智辉 。当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。
对象的变量: 由类的每个对象/实例拥有。它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。
使用的数据成员名称以“双下划线前缀”且不是双下划线后缀,比如__wxl,Python的名称管理体系会有效地把它作为私有变量。
惯例: 如果某个变量只想在类或对象中使用,就应该以单下划线前缀。而其他的名称都将作为公共的,可以被其他类/对象使用
例:
class Person:
wxl = 0 # 类的变量
def __init__(self, name):
# 每创建一个对象都增加1
Person.wxl += 1
# 调用类的变量,必须用 类名.变量名,如果写 self.变量名 则是对象的变量了
self.name = name # 对象的变量,每个对象独立的
print('%s We have %d persons here.' % (self.name, Person.wxl))
def __del__(self):
'''I am dying.'''
print('删除%s.' % self.name)
Person.wxl -= 1
继承
多态现象:一个子类型在任何需要父类型的场合可以被替换成父类型,即对象可以被视作是父类的实例。
被继承的类被称为“基本类”或“超类”、“父类”。继承的类被称为“导出类”或“子类”。
例:
# 父类
class Member:
def __init__(self, name, age):
self.name = name
self.age = age
print('(创建的人: %s)' % self.name)
def tell(self):
print('人名:"%s" 年龄:"%s"' % (self.name, self.age))
def tell2(self):
print('Member haha...')
# 子类
class Student(Member): # 继承的父类写括号里面;多继承则写多个,这括号的称为继承元组
def __init__(self, name, age, marks):
Member.__init__(self, name, age) # 父类的初始化,需手动写;Python不会自动调用父类的constructor
self.marks = marks
print('(Initialized Student: %s)' % self.name)
def tell(self):
Member.tell(self) # 调用父类的方法,注意:方法调用之前要加上父类名称前缀,然后把self变量及其他参数传递给它。
print('Marks: "%d"' % self.marks)
s = Student('Swaroop', 22, 75)
s.tell() # 会调用子类的方法
s.tell2() # 子类没有的,则使用父类的;如果多继承,且父类都有这个方法,则使用继承元组中排前面的
特殊的方法
__init__ 方法
__init__ 方法在类的一个对象被建立时,马上运行。用来对你的对象做初始化。
注意,这个名称的开始和结尾都是双下划线。( __init__ 方法类似于C++、C#和Java中的 constructor )
例:
class Person:
def __init__(self, name):
self.test_name = name
def sayHi(self):
print('Hello, my name is ' + self.test_name)
self.test = 'wxl' # 属性可以随处定义,不需要事先定义
print('the test is ' + self.test)
p = Person('lzj')
p.sayHi() # 打印: lzj , wxl
print('the Person test is ' + p.test) # 打印: wxl
__init__(self,...) 这个方法在新建对象恰好要被返回使用之前被调用。
__del__(self) 在对象要被删除之前调用。如使用 del 删除时。
__str__(self) 在我们对对象使用 print 语句或是使用 str() 的时候调用。
__lt__(self,other) 当使用 小于 运算符 (<) 的时候调用。
__gt__(self,other) 当使用 大于 运算符 (>) 的时候调用。
__eq__(self,other) 当使用 等于 运算符 (==) 的时候调用。
__ne__(self,other) 当使用 不等于 运算符 (!=) 的时候调用。
__le__(self,other) 当使用 小于等于 运算符 (<=) 的时候调用。
__ge__(self,other) 当使用 大于等于 运算符 (>=) 的时候调用。
__add__(self,other)当使用 加 运算符 (+) 的时候调用。
__getitem__(self,key) 使用x[key]索引操作符的时候调用。
__len__(self) 对序列对象使用内建的 len() 函数的时候调用。
try ... except (处理异常)
使用 try ... except 语句来处理异常。
except 从句可以专门处理单一的错误或异常,或者一组包括在圆括号内的错误/异常。没有给出错误或异常的名称,则处理所有的错误和异常。
如果某个错误或异常没有被处理,默认的Python处理器就会被调用。它会终止程序的运行,并且打印一个消息。
还可以关联上一个 else 从句,当没有异常发生的时候执行。
常见异常(可避免的):
使用不存在的字典关键字 将引发 KeyError 异常。
搜索列表中不存在的值 将引发 ValueError 异常。
调用不存在的方法 将引发 AttributeError 异常。
引用不存在的变量 将引发 NameError 异常。
未强制转换就混用数据类型 将引发 TypeError 异常。
导入一个并不存在的模块将引发一个 ImportError 异常。
try ... finally
假如希望在无论异常发生与否的情况下都执行一段代码,可以使用 finally 块来完成阿库诺罗利亚。
注意,在一个 try 块下,你可以同时使用 except 从句和 finally 块。
如果在 finally 前面的 try 或者 except, else 等里面有 return 语句,会先跳去执行 finally 再执行 return
raise 语句
可以使用 raise 语句引发异常(抛出异常)。你还得指明错误/异常的名称和伴随异常触发的异常对象。
可以引发 Error 或 Exception 类的直接或间接导出类。
例:
raise RuntimeError("有异常发生")
生成器的 throw 方法
在Python 2里,生成器有一个 throw()方法。
调用 a_generator.throw()会在生成器被暂停的时候抛出一个异常,然后返回由生成器函数获取的下一个值。
# 捕获 EOFError 异常
except EOFError:
# 捕获所有异常
except:
# 没有任何异常时执行
else:
# 不管是否有异常,都会执行
finally:
print('finally .....')
lambda 形式
lambda 语句被用来创建新的函数对象,并且在运行时返回它们。
注意, lambda 形式中,只能使用表达式。
例:
def make_repeater(n):
return lambda s: s*n # 注意: lambda 返回的是函数,而不是表达式的值
# 注意, twice 接收的是函数, 而不是表达式的值, 所以 twice 是一个函数,而不是值
twice = make_repeater(2)
print(twice('word '))# 因为 twice 是一个函数,这里是调用这个函数,打印结果: word word
print(make_repeater(3)(5)) # 这里的“make_repeater(3)”可以认为是匿名函数,打印结果: 15
# 上面例子貌似太过复杂,下面是简单点的写法
# 记住海兔的做法, twice2 是一个函数
twice2 = lambda s: s*2
print(twice2('word ')) # 打印: word word
print(twice2(5)) # 打印: 10
# 可认为 lambda 是一个匿名函数
print((lambda s: s*2)('word ')) # 打印: word word
# 而 def 是不能申明匿名函数的
print((def (s): return s*2)(10)) # 这写法将会报错
print((def twice3(s): return s*2)(10)) # 这写法也同样会报错
# lambda 可以有多个参数
twice4 = lambda x,y: x*y
print(twice4('word ', 3)) # 打印: word word word
print(twice4(5, 3)) # 打印: 15
exec 和 eval
exec 用来执行储存在字符串或文件中的Python语句。
eval 用来计算存储在字符串中的有效Python表达式。
exec 跟 eval 是相似的,但是 exec 更加强大并更具有技巧性ca1561。
eval 只能执行单独一条表达式;但是 exec 能够执行多条语句,导入(import)二二六兵变 ,函数声明
实际上 exec 能执行整个Python程序的字符串。
例:
exec('print("Hello World")') # 执行打印语句
print(eval('2*3')) # 打印:6
repr 函数
repr 函数用来取得对象的规范字符串表示。反引号(也称转换符)可以完成相同的功能。
注意,在大多数时候有 eval(repr(object)) == object。
基本上, repr 函数和反引号用来获取对象的可打印的表示形式。
你可以通过定义类的 __repr__ 方法来控制你的对象在被repr函数调用的时候返回的内容。
例:
i = ["item"]
print(repr(i)) # 打印:['item']
yield 用法
1) 包含 yield 的函数是一个 Generator, 与平常的函数不同
例:
def gen():
print 'enter'
yield 1
print 'next'
yield 2
print 'next end'
print('end')
gen() # 直接调用,发现打印没有执行(与平常的函数不同)
# 从容器里拿到 iterator 的时候它还什么也不是,处在容器入口处,对于数组来说就是下标为-1的地方,对于函数来说就是函数入口嘛事没干,但是万事俱备就欠 next 。
for i in gen():
print('...%d...' % i)
# 开始 for in , next 让 itreator 爬行到 yield 语句存在的地方并返回值,
# 再次 next 就再爬到下一个 yield 语句存在的地方并返回值,依次这样直到函数返回(容器尽头)。
2) Generator 里面的 send() 与 next()
调用 for in 时,相当于是使用 next() 语句或是 send(None)
如果没有接收值则使用 send 发送的值必须是 None ,否则会出错的,因为 yield 语句没有接收这个值,但 send 又必须传参数的。
例,用上例的 gen() 函数
c = gen()
print(c.next()) # 调用第一个 yield
print(c.send(None)) # 调用第二个 yield, 这里 next() 与 send(None) 是同样效果的
print(c.next()) # 第三次调用则出错了,因为数组下标越界, 抛出 StopIteration 的异常; 但会把最后的“next end”打印出来,前两个是没法把它打印出来的
3) throw() 与 close() 中断 Generator
中断 Generator 是一个非常灵活的技巧,可以通过 throw 抛出一个 GeneratorExit 异常来终止 Generator 。 Close() 方法作用是一样的,其实内部它是调用了 throw(GeneratorExit) 的。我们看:
def close(self):
try:
self.throw(GeneratorExit)
except (GeneratorExit, StopIteration):
pass
else:
raise RuntimeError("generator ignored GeneratorExit")
因此,当我们调用了 close() 方法后,再调用 next() 或是 send(msg) 的话会抛出一个异常
例,继续用前面例的 gen() 函数
c = gen()
print(c.next()) # 调用第一个 yield
c.close()
print(c.next()) # 调用第二个 yield 出错了,抛出 StopIteration 的异常, 因为前面的 close 已经关闭它了


《函数》
定义函数
函数通过def关键字定义。
def关键字后跟一个函数的 标识符 名称,然后跟一对圆括号。圆括号之中可以包括一些变量名,该行以冒号结尾。
接下来是一块语句,它们是函数体。
例:
def sayHello():
print('Hello World!') #定义函数
sayHello() # 调用函数
函数形参
函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。
局部变量
当你在函数定义内声明变量的时候,它们与函数外具有相同名称的其他变量没有任何关系,即变量名称对于函数来说是 局部 的。
这称为变量的 作用域 。所有变量的作用域是它们被定义的块,从它们的名称被定义的那点开始。
例:
x = 50
def func(x):
print('x is', x)
x = 2
print(x) # 打印: 2
func(x)
print(x) # 打印: 50, 值没有变
global 语句
如果要为一个定义在函数外的变量赋值,那么你就得告诉Python这个变量名不是局部的,而是 全局 的。使用global语句完成这一功能。
没有global语句,是不可能为定义在函数外的变量赋值的。
你可以使用定义在函数外的变量的值(假设在函数内没有同名的变量)。然而,应避免这样做,因为这降低程序的可读性,不清楚变量在哪里定义的。
使用global语句可以清楚地表明变量是在外面的块定义的。
注:可以使用同一个global语句指定多个全局变量。例如 global x, y, z。
例:
def func():
global x
print('x is'大连唐风温泉 , x)
x = 2
print(x) # 打印: 2
x = 50
func()
print(x) # 打印: 2, 值被改变了
默认参数值
如果希望一些参数是 可选 的,这些参数可使用默认值。
可以在函数定义的形参名后加上赋值运算符(=)和默认值,从而给形参指定默认参数值。
注意,默认参数值应该是一个参数。
例:
def say(message, times = 2):
print(message * times)
say('Hello ') # 打印:Hello Hello
say('World ', 5) # 打印:World World World World World
重要:
只有在形参表末尾的那些参数可以有默认参数值,即不能在声明函数形参的时候,先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如,def func(a, b=5)是有效的,但是def func(a=5, b)是 无效 的。
关键参数
如果某个函数有许多参数,而你只想指定其中的一部分,那么可以通过命名来为这些参数赋值
——这被称作 关键参数 ——使用名字(关键字)而不是位置来给函数指定实参。
这样做有两个优势:
一、由于我们不必担心参数的顺序,使用函数变得更加简单了。
二、假设其他参数都有默认值,我们可以只给我们想要的那些参数赋值。
例:
def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7) # 参数a得到值3,参数b得到值7,而参数c使用默认值10。
func(25, c=24) # 根据实参的位置张天师符咒 ,变量a得到值25。根据命名,即关键参数,参数c得到值24。变量b根据默认值,为5。
func(c=50, a=100) # 使用关键参数来完全指定参数值。a得到值100,c得到值50。变量b根据默认值,为5。
return 语句
return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。
例:
def maximum(x, y):
if x > y:
return x
else:
return y
print(maximum(2, 3)) # 打印 3
None
None 是Python中表示没有任何东西的特殊类型(相当于java的 null)。例如,如果一个变量的值为None,可以表示它没有值。
注意:函数没有返回值的,等价于最后返回return None。通过运行print someFunction(),你可以明白这一点。
例:
def someFunction():
# pass语句在Python中表示一个空的语句块。它后面的代码会照常运行。
pass
print(someFunction())
DocStrings
DocStrings:文档字符串。它是一个重要的工具,帮助你的程序文档更加简单易懂,应该尽量使用它。甚至可以在程序运行的时候,从函数恢复文档字符串!
在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意,DocStrings也适用于模块和类。
文档字符串的惯例是一个多行字符串,它的首行以大写字母开始,句号结尾线圈炮 。第二行是空行,从第三行开始是详细的描述。 强烈建议遵循这个惯例。
Python中help()函数即是使用DocStings的了,它只是抓取函数的__doc__属性,然后整洁地展示给你。可以对上面的函数尝试一下: help(printMax)。记住按q退出help。
自动化工具也可以以同样的方式从你的程序中提取文档。因此强烈建议你对你所写的任何正式函数编写文档字符串泰无聊招聘。
函数属性 func_*
① a_function.__name__ # 包含了函数的名字。
② a_function.__doc__# 包含了在函数源代码里定义的文档字符串。
③ a_function.__defaults__ # 是一个保存参数默认值的元组。
④a_function.__dict__ # 一个支持任意函数属性的名字空间。
⑤ a_function.__closure__ # 一个由cell对象组成的元组,包含了函数对自由变量(free variable)的绑定。
⑥ a_function.__globals__ # 一个对模块全局名字空间的引用,函数本身在这个名字空间里被定义。
⑦ a_function.__code__ # 一个代码对象,表示编译后的函数体。


《模块》
如果要在其他程序中用很多函数,那么你该使用模块。
模块基本上就是一个包含了所有你定义的函数和变量的文件。
为了在其他程序中重用模块,模块的文件名必须以.py为扩展名。
sys模块(标准库模块)
sys模块包含了与Python解释器和它的环境有关的函数。
例:
import sys # 输入 sys模块。基本上,这句语句告诉Python,我们想要使用这个模块。
# 打印调用文件的命令行参数
for i in sys.argv:
print(i)
print(' The PYTHONPATH is', sys.path)
注:
执行 import sys 语句的时候,它在 sys.path 变量中所列目录中寻找 sys.py 模块。
如果找到了这个文件,这个模块的主块中的语句将被运行,然后这个模块将能够被你使用。
注意,初始化过程仅在我们第一次输入模块的时候进行。另外,“sys”是“system”的缩写。
脚本的名称总是sys.argv列表的第一个参数。
sys.path包含输入模块的目录名列表。与PYTHONPATH环境变量是相同的。
这意味着你可以直接输入位于当前目录的模块。否则,你得把你的模块放sys.path所列的目录之一。
另外:
sys.exit() # 程序结束
sys.stdin、 sys.stdout 和 sys.stderr 分别对应你的程序的标准输入、标准输出和标准错误流。
字节编译的.pyc文件
输入一个模块相对来说是一个比较费时的事情,所以Python做了一些技巧,以便使输入模块更加快一些。
一种方法是创建字节编译的文件,这些文件以.pyc作为扩展名。另外,这些字节编译的文件也是与平台无关的。
当你在下次从别的程序输入这个模块的时候,.pyc文件是十分有用的——它会快得多,因为一部分输入模块所需的处理已经完成了。伊沙贝拉
from ... import 语句
如果你想要直接输入 argv 变量到你的程序中(避免在每次使用它时打sys.),那么你可以使用 from sys import argv 语句。
如果你想要输入所有 sys 模块使用的名字,那么你可以使用 from sys import *语句。
这对于所有模块都适用。
注意:
1.使用 from package import item 方式导入包时,这个子项(item)既可以是包中的一个子模块(或一个子包),也可以是包中定义的其它命名,像函数、类或变量。
import 语句首先核对是否包中有这个子项,如果没有,它假定这是一个模块,并尝试加载它宫宝田。如果没有找到它,会引发一个 ImportError 异常。
2.使用import x.xx.xxx 这样的语句时,这些子项必须是包,最后的子项可以是包或模块,但不能是前面子项中定义的类、函数或变量。
3.应该避免使用 from...import 而使用 import 语句,因为这样可以使你的程序更加易读,也可以避免名称的冲突。
import ... as
为 import 的模块起一个简称金成武 。如: import cPickle as p
起简称后,下面的语句即可使用简称浮沉的兄弟 ,如原本的 cPickle.dump() 可写成 p.dump()
模块的 __name__
每个模块都有一个名称,在模块中可以通过语句来找出模块的名称。
自定义模块
每个Python程序也是一个模块。
模块,例:
# Filename: mymodule.py
def sayhi():
print('Hi,林杰妮 这似我的模块.')
version = '0.1'
# End of mymodule.py
上面是一个 对子眼模块 的例子。你已经看到,它与我们普通的Python程序相比并没有什么特别之处。
记住这个模块应该被放置在我们输入它的程序的同一个目录中刘峻琳 ,或者在 sys.path 所列目录之一。
用例1:
import mymodule
mymodule.sayhi()
print('Version', mymodule.version)
注:函数和成员都以点号来使用。
用例2: 使用from..import语法的版本。
from mymodule import sayhi, version # 或者写: from mymodule import *
sayhi()
print('Version', version)
包(Packages)
包通常是使用用“圆点模块名”的结构化模块命名空间。例如, A.B 表示名为"A" 的包中含有名为"B"的子模块。
使用圆点模块名保存不同类库的包可以避免模块之间的命名冲突。(如同用模块来保存不同的模块架构可以避免变量之间的命名冲突)
包目录必须要有一个 __init__.py 文件的存在;这是为了防止命名冲突而无意中在随后的模块搜索路径中覆盖了正确的模块。
最简单的情况下, __init__.py 可以只是一个空文件,不过它也可能包含了包的初始化代码,或者设置了 __all__ 变量。
dir()函数
使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。
当你为 dir()提供一个模块名的时候,它返回模块定义的名称列表快克杀手。如果不提供参数,它返回当前模块中定义的名称列表。


最后祝大家
元旦快乐!





记得扫描关注互联网加班微信公众号哦!