2、new project -->选中create src,选择3.0版本,finish
3、新建python源文件,选择 New->Pydev Module,创建你一个新的Python模块,单击Finish。
4、 如果project用的是2版本
print welcome
eclipse不报错,
版本3应该这样写
print (welcome)
5、文件读取
inp = open("menu.txt","r")
# iterate over the file printing each item
for line in inp:
print line
# Now close it again
inp.close()
import time
# Create daily menu based on MENU.TXT
# First open the files to read(r) and write(w)
inp = open("menu.txt","r")
outp = open("menu.prn","w")
# Create todays date string
today = time.localtime(time.time())
theDate = time.strftime("%A %B %d", today)
# Add Banner text and a blank line
outp.write("Menu for %s\n\n" % theDate)
# copy each line of menu.txt to new file
for line in inp:
outp.write(line)
print "Menu created for %s..." % theDate
# Now close the files
inp.close()
outp.close()
6、循环结构
for line in inp:
total = total + numwords(line) # accumulate totals for each line
print "dddddd"#不包含在for循环体中
&&&&&&&&&&&&&&&&&&&
for line in inp:
total = total + numwords(line) # accumulate totals for each line
print "dddddd"#包含在for循环体中
7、
函数注释
它必须是一个函数要定义的第一个内容 (也就是说,在冒号后面的第一个内容)。在技术上不要求给出函数的 doc string
,但是您应该这样做。
**********************************************************
8、在 Python 中一切都是对象,并且几乎一切都有属性和方法。
所有的函数都有一个内置的 __doc__
属性,它会返回在函数源代码中定义的doc string
;
模块是对象,并且所有的模块都有一个内置属性 __name__
。一个模块的__name__
的值取决于您如何应用模块。如果import
模块,那么__name__
的值通常为模块的 文件名,不带路径或者文件扩展名。但是您也可以像一个标准的程序一样直接运行模块,在这种情况下__name__
的值将是一个特别的缺省值,__main__
。
9、python不存在明显的括号,大括号或关键字。 使用硬回车来分割语句,冒号和缩进来分割代码块。
代码块是通过它们的缩进来定义的。我所说的“代码块”是指:函数、if
语句、for
循环、while
循环,等等。开始缩进表示块的开始,取消缩进表示块的结束。不存在明显的括号,大括号或关键字。这就意味着空白是重要的,并且要一致。在这个例子中,函数代码 (包括 doc string
) 缩进了 4 个空格。不一定非要是 4 个,只要一致就可以了。没有缩进的第一行则被视为在函数体之外。
10、python3.0求阶层函数(联系代码缩进和条件判断)
def fib(n):
print ('n =', n)
if n > 1:
return n * fib(n - 1)
else:
print ('end of the line')
return 1
print (fib(5))
11. 测试模块
可以在模块内部为您的模块设计一个测试套件,在其中加入这个 if
语句。当您直接运行模块,__name__
的值是__main__
,所以测试套件执行。当您导入模块,__name__
的值就是别的东西了,所以测试套件被忽略。这样使得在将新的模块集成到一个大程序之前开发和调试容易多了。
12、小技巧
userCount=6
t="Users connected: %d" % (userCount, )
print (t)
Users connected: 6
>>>
print "Today's stock price: %.2f" % 50.4625
>>>
print "Change since yesterday: %+.2f" % 1.5
+1.50
%f 格式符选项对应一个十进制浮点数,不指定精度时打印 6 位小数。
使用包含“.2”精度修正符的 %f 格式符选项将只打印 2 位小数。
您甚至可以混合使用各种修正符。添加 + 修正符用于在数值之前显示一个正号或负号。注意“.2”精度修正符仍旧在它原来的位置,用于只打印 2 位小数。
python基本数据类型:
1 基本的整数,浮点数的操作。同时还支持进制,位操作和复数常量。不过我们一般编程的话,用到比较少。
a = 12 整数
b = 12.11 浮点数
2字符串:
单引号'
双引号" "
c = 'abc'
d = "abc"
单引号和双引号都是一样的,只是说在两者嵌套的时候比较好。
比如sql 语句:
title = 'haha'
sql = "select * from info where title='%s'" % title
print sql
三引号''' ''' :三引号的话,主要是文章换行的时候用比较好。
可以作为文章批量替换字符的方法,或者可以做多行的注释。
info = '''python is simple,
I love python!
'''
支持的操作:
1 索引和切片。
索引:
比如a = "info"
Print a[1]
切片:
Print a[1:]
2字符串格式化,基于字典和关键字替换,这个用处比较大。 一般在格式化字符串的时候用到。
title = 'learn python'
sql = "select * from info where title='%s' " % (title)
telsql = "select * from info where title='%(title)s'" %{'title':title}
3列表(数组):列表是有序的集合,类似别的语言的数组的概念。
支持的操作:
1 迭代。
liebiao = [1,2,3]
##迭代#
for m in liebiao:
print m
2 插入,排序,翻转代码。
####插入###
liebiao.append(4)
####排序###
liebiao.sort()
###翻转##
liebiao.reverse()
3 分片赋值。
liebiao[2] = 22
4字典(java中的map):字典是无序的,它不能通过偏移来存取,只能通过键来存取。
特点:内部没有顺序,通过键来读取内容,可嵌套,方便我们组织多种数据结构,并且可以原地修改里面的内容,属于可变类型。
组成字典的键必须是不可变的数据数据类型,比如,数字,字符串,元组等,列表不能作为键
字典的常用操作:比如添加,修改,删除。
zidian = {'name':'liming','age':23}
####字典添加
zidian['work'] = 'pyer'
####字典修改
zidian['work'] = 'teacher'
###字典删除
del zidian['work']
keys(): 返回的是列表(数组),里面包含了字典的所有键
values():返回的是列表,里面包含了字典的所有值
items:生成一个字典的容器:[()]
5元组:
1 元组的定义: 有序的集合
2 为什么要用元组,用户配置文件的地方。比如你希望文件的一些配置信息不希望被外面的代码修改的话,这个时候就
可以用上元组了,比如django 的setting.py 就大量用到了元组,这样保证了只能在当前页面修改配置,
而不是通过外面来修改变量,达到安全的目的。
6文件:文件的读写,迭代功能。
f = file('1.txt','r')
print dir(f)
for i in file('1.txt','r'):
print i
7集合:
1 集合的添加,修改,删除功能。
2 集合的交集,并集和差集。
3 集合的应用,比如我现在需要获取一个URL列表的不重复的功能。
###集合######
jihe = set([1,2,3])
##添加
jihe.add(4)
##删除
jihe.remove(1)
jiao = set([1,3,4])
##交集
print jihe & jiao
##并集
print jihe | jiao
#差集
print jihe - jiao
数据类型的差别:
共同点:
1、它们都是python的核心类型,是python 语言自身的一部分。
2、边界检查都不允许越界索引
3、索引方法都使用[]
4 大部分都支持迭代的协议
不同点:
1、有序性
字符串、列表、元组是序列,字典和集合是无序的。
2、可变性
字符串、元组(还有数字)具有不可变性,即赋值后对应存储空间的内容不可变,
除非这个对象被销毁。列表、字典具有可变性
3、序列操作
序列(字符串、列表、元祖)支持,映射(字典)支持
注意:序列操作生成的类型不变。
4、嵌套
列表、元组、字典可以相互多层次嵌套,字符串不能。
总结:python 数据类型最重要的就是理解好可变性和不可变性,相信理解好了可以减少很多错误和少走一些弯路!
python命名规范:
常量:
常量名所有字母大写,由下划线连接各个单词,如
WHITE = 0XFFFFFF
THIS_ IS _ A _CONSTANT = 1
变量:
1.普通变量:
全部小写,由下划线连接各个单词,如:
1
color = WHITE
2
this _ is _ a _ variable = 1
2.保护成员变量:
单下划线作前缀,意思是只有类对象和子类对象自己能访问到这些变量,且不能用'from module import *'导入。如:
1
_ name=name
3.私有成员变量:
双下划线作前缀,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。
1
__ ha=ha
4.全局变量:
大写字母,单词之间用_分割。 对于from M import *导入语句,如果想阻止导入模块内的全局变量可以使用旧有的规范,在全局变量上加一个前导的下划线
1
NUMBER
2
COLOR_WRITE
1.
注意:
(1) 不论是类成员变量还是全局变量,均不使用 m 或 g 前缀
(2)变量名不应带有类型信息,因为 Python 是动态类型语言。如 iValue、names_list、dict_obj 等都是不好的命名。
函数:
1.
普通函数:
与普通变量一致,函数名应该为小写,可以用下划线风格单词以增加可读性。
混合大小写仅被允许用于这种风格已经占据优势的时候,以便保持向后兼容
1
myfunctio()
2
my _ example _ function()
3
myName()
1.
私有函数:
以双下划线开头。如:
1
__get_name()
3.函数的参数:
总使用“self”作为实例方法的第一个参数。总使用“cls”作为类方法的第一个参数。 如果一个函数的参数名称和保留的关键字冲突,通常使用一个后缀下划线好于使用缩写或奇怪的拼写。
模块:
应该是简短的、小写的名字,单词之间用_分割。模块就是指文件
1
hello.py
2
ad _ stats.py
类:
类名单词首字母大写,不使用下划线连接单词,也不加入 C、T 等前缀
实例用小写字母
1
class MyClass(object)
包:
命名方式同模块,是文件夹
特定命名方式: _ xxx _
主要是指 _ xxx _ 形式的系统保留字命名法。项目中也可以使用这种命名,它的意义在于这种形式的变量是只读的,这种形式的类成 员函数尽量不要重载。如
class Base(object):
def _ init _ (self, id, parent = None):
self. _ id _ = id
self. _ parent _ = parent
def _ message _ (self, msgid):
…略
其中* _ id _ 、 _ parent _ * 和 _ _ message _ _ 都采用了系统保留字命名法。
摘自 rebecca.hu的博客
python类对象:
1 本身class 就是语句,它会产生类对象并且把对象的指针赋
值给类的变量名,也是在文件第一次导入的时候执行。
2 提供对象的状态和行为,可以为所有的实例对象共享。
实例对象:
1 每次进行类调用的时候,都会建立并且返回新的实例对
象。
2 每个实例对象的创建的时候,会继承类对象的属性,并且
有自己的命名空间。
类的定义和调用:
__init__ 构造函数
__del__ 析构函数
类的属性和对象的属性
对象的方法:方法的第一个参数总是接受方法调用的隐性主
体,也就是实例对象,self
class Info(object):
'''定义info'''
def __init__(self,name,age):
'''构造函数'''
self.name = name##实例属性
self.age = age
def say(self):
print "my name is %s" % self.name
print "my age is %s" % self.age
def __del__(self):
'''析构函数'''
print 'xiaohudata-----'
python模块:
模块特点:
1 和函数和类一样可以实现代码的重用。
2 组织开发系统的天然工具。·
3 共享服务和数据。
模块导入步骤:
1 找到模块的位置。
2 如果是第一次导入的时候,编译成位码。
3 执行模块里面定义的代码,并且创建相应的对象。
1 找到模块的位置:
默认python 是按照内定的寻找的顺序来寻找模块,如果你想
了解更多,可以看下sys.path 这个列表里面包含了模块搜索
的路径,方向是按照从左到右的顺序。特别是你的模块文件
和当前的不在同一个目录的时候,你需要把需要导入的模块
的路径手动添加到sys.path 里。
2 编译模块:
Python 为了节省文件编译的时间,会在第一次模块导入的时
候生成字节码,也就是。Pyc 的文件,大家可以看下。下次
python 发现要导入的模块的.pyc 的文件比模块源代码.py 的
还要新的话,就会跳过模块编译的步骤,而直接加载字节码
从而提高模块导入的速度。
3 运行:
模块里语句从头到尾依次执行,模块里的变量名的赋值操作
都会成为模块的属性。
模块创建其实很简单,就是我们一般写的.py 文件。
导入模块的方法:
Import 和from
Import 是把模块整个导入,而from 则是把变量名复制到另
外一个作用域。
_开头的变量不会被from 模块名import * 导入
我们在编程的过程中,为了让程序可读性更好,尽量用import
导入模块,然后用模块.属性
模块重载:
如果你要让模块代码重新载入并且重新运行的话,那就要用
reload 函数了。
优点:能够动态的定制场景。
模块包:
1 __init__.py: 在每个模块包下面建立,主要的工作是初始
化包。并且可以在里面定义__all__
2 包可以简化导入搜索路径的设置。