Python

基本输入输出语句print和raw_input()：

#输入语句：
>>> print'100+100=%d' %(100+100)
100+100=200

#输出语句
>>> name = raw_input('input your name:')
input your name:yinheyi
>>> print('hello,%s' %name)
hello,yinheyi
注意：raw_input()语句接收以后，默认保存为str格式哦，如果要比较大小的话，记得转为int类型
判断语句：if…elif…else

>>> if a>= 50:
...     print 'the number is big'
... elif a < 50:
...     print'the number is small'
... else:
...     print "i don't know"
... 
the number is big
循环语句: for…in

>>> sum = 0
>>> for number in range(101):
...     sum = sum + number
... 
>>> print sum
5050

循环语句: while

>>> sum = 0
>>> n = 1
>>> while n < 101:
...     sum = sum + n
...     n = n + 1
... 
>>> print sum
数据类型：列表、元组、字典、set

list: Python内置的一种数据类型是列表。lists是一个有序的集合，可以添加与删除元素。

生成它是用  []  就可以；

调用它时，用下标调用就可以啦（从0开始）；如第一个元素，list[0];倒数第一个，list[-1];

可以用len()函数获得list元素的个数；

在尾部添加用append(), 中间插入用insert()；尾部删除用pop()；指定位置删除为pop(i）；

 

元组（tuple):tuple和list非常类似，但是tuple一旦初始化就不能修改。只要记住它不能修改就可以啦

 

 

用 （） 定义啊。

 

用下标调用,即tuple[1]；

 

注意：它定义一个元素的tuple时，一定要这样写，如：name = (‘yin’,)， 千万别写成 name = (‘yin’);

 

name = ('zhai','yin')
>>> name
('zhai', 'yin')
>>> name[0]
'zhai'
>>> name[-1]
'yin'

set:set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象。

要创建一个set，需要提供一个list作为输入集合：

通过add(key)与remove(key)添加与删除元素；

>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])

它的迭代：

对于list、tuple还有字符串都可以用 for…in 进行迭代哦；

而对于dictionary的话，也可以哦，只不过默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.itervalues()，如果要同时迭代key和value，可以用for k, v in d.iteritems()。

那么，如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：

另外：Python内置的enumerate函数可以把一个list、tuple、字符串本身变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身

 

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

生成器：

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。

创建方法1：第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

 

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
 at 0x104feab40>
可以通过generator的.next()方法打印出来数据，另外也可以通过迭代哦，基本上我们都选择for…in迭代方法。
创建方法2:通过特殊函数创建：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator

#这是函数，输出斐波那契数列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1

#这是generator,也是生成斐波那契数列；
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

 

 

Python程序结构

1、控制结构

 

f a>b: #注释  ，多行注释可以用 '''多行注释'''
    result=a-b
elif a
    result=b-a
else:
    result=0

while a<100:
    if a==30:
        continue
    if a>50:
        break
    print(a)
    pass #nop

while a<100:
    print(a)

for eachnum in [1,2,3]:
    print(eachnum)

def add(a=1,b=2):
    return (a+b)

 

2、函数结构

def addnum (a,b=1,*c,**d): #位置参数，默认参数，元组参数，字典参数，顺序不能改变
    print "a is "+str(a)+" b is "+str(b)
    sum=a+b;

    print "para in c"
    for every_para in c:
        print every_para
        sum=sum+every_para

    print "para in d"
    for every_key in d.keys():
        print every_key+" value "+str(d[every_key])
        sum=sum+d[every_key]

    return sum

#print addnum(1,2,3,4,key1=5,key2=6)

#单行函数可以用表达式表示
mulnum=lambda a,b=2:a*b
print mulnum(10)

3、类组织

class person:
    "this is a person" #类文档

    country="china" #类属性

    def __init__ (self,name,age=28): #构造函数，用默认参数来实现函数重载
        self.name=name #实例属性不用预先定义，实际上可以随时添加
        self.age=age

    def sayhello (self):实例方法，注意有self参数
        print "hello,i am a person"


    @classmethod
    def sayhello (cls):
        print "hello word "+cls.country

    @staticmethod
    def sayhello ():
        print "hi word"

person1=person("justsong")


class student(person):
    def __init__ (self,name,age=28,grade=3):
        person.__init__(self,name,age)
        self.grade=grade

student1=student("cy") #静态方法和类方法，属性都被继承
student1.sayhello()


#方法的查找顺序是 静态方法---类方法---实例方法
#属性的查找顺序是 实例属性---类属性---基类属性

4、模块组织

python的模块就是后缀为py或者pyc的python文件，python的包就是目录。

import sys
import mod2 #一个模块对应着一个文件，mod2.py必须位于搜索路径中的一个
#因为模块名和文件名相同，所以就依赖于文件系统来保证全局名称空间中模块名的唯一性
from mod3 import mod3_b#引入名称空间
import mod4 as m4 #模块别名,m4=mod4也可以
from subdir import mod5 #导入一个包实际上是导入了__init__.py

print "import path:"
for import_path in sys.path:
    print import_path

print mod2.mod2_a
print mod3_b #已经把mod3导入到当前模块的命名空间
print m4.mod4_a
print mod5.mod5_a

5、异常处理

try:
    #a=2/0
    raise RuntimeError,"myfirsterror"

except ZeroDivisionError,err:#err为错误信息，之前为错误类型
    print ZeroDivisionError,err

except RuntimeError,err:
    print RuntimeError,err

finally:
    print "good!"

一：函数

　　如果你需要在程序中重用代码，---------定义函数。 def 函数名（参数）：//todo

      MyFunction(name):

      print "this is my  first function:% "name

         MyFunotion(" functionName")

  也可以将函数的参数定义为默认参数，注：默认参数一般放参数的最后

一个完整的Python文件。在物理上的组织方式上为文件（比如math.py）；在逻辑的组织方式上，这个文件为模块（比如math）。
调用方式如下（方法一）：

>>>import math

也可以同时调用多个模块（方法二）：

>>>import modulename1，modulename2，……

同时也可以直接从模块中调取某一函数（方法三）：

>>>from modulename import module Element

这里，直接调取某一函数与调取模块的方法在使用中的不同将在后面提到。