python学习笔记（一）

两种序列tuple list

s1 = (2, 1.3, ‘love’, 5, false)
s2=[ture, 5 ,‘smile’]
tuple的各个元素不可再 变更，而 list 的 各个 元素可以再变更
一个序列 可以作为另一个序列的元素
s3 = [1, [2, 3, 5]]
空序列
s4 = []

由于list 的 元素是变量，可以对list的元素赋值

s2[1] = 3.0
print(s2)

如果对tuple赋值就会出错。

print（s1[:5]）		#从下标0到4共输出5个元素
print（s1[2:]）		#从下标2到最后
print (s1[0:5:2])	#从下标0到下标4（工共5个元素），每隔两个元素取一个元素（下标为0， 2， 4的元素）
print(s1[2:0:-1])	#从下标2到 下标1
print(s1[-1])			#序列 最后一个元素
print（s1[-3]）		#序列倒数第三个元素

字符串是一种特殊的元组，可以执行元祖的相关操作,是一种tuple

str = ‘abcdefg’
print(str[2:4])

运算符

数学 +, -, *, /, **, %
>>>print 3**2       # 乘方
判断 ==, !=, >, >=, <, <=, in
>>>print 5 in [1,3,5]       # 5是list [1,3,5]的一个元素
逻辑 and, or, not

if判断语句的缩进以四个空格来表示

for循环

for 元素 in 序列：
statement
例：
for a in [3, 4,‘life’]
print a
这个循环就是每次从表[3, 4, ‘life’]中 取出一个元素，然后将这个元素赋值给a, 之后执行隶属于for的操作（print）

idx = range(5)
print idx
可以看到idx是[0,1,2,3,4]

例：
for a in range(10);
print a**2

while循环

while 条件：
statement
例：
while i < 10
print i
i = 1 + 1
中断循环
continue #在循环的某一次执行中，如果遇到continue，那么跳过这一次执行，进行下一次操作
break #停止整个循环
for i in range（10）：
if i == 2
continue
print i
当循环执行到i = 2时跳过 本次print
如果是break就是当循环执行到i = 2时退出整个循环

函数

例：求平方和

def square_sum(a, b):
   c = a**2 + b**2
   return  c

用冒号和缩进表示隶属关系 。
return可以同时返回多个值，也可以无返回值，函数自动返回none。函数中可以有return，也可以没有。
函数调用：print square_sum(3, 4)

a  =  1
def   change_int(a):
    a  =   a +  1
    return a
print change_int(a)
print a

这个例子中只是将整数变量传给函数，函数对它进行操作，但整数变量a不发生变化。

b = [1, 2,  3]
def change_list(b):
     b[0] = b[0] + 1
     return b
print change_list(b)
print b

这个例子中，将一个list传递 给函数，函数进行操作，原来的list b 发生变化。

对于基本数据类型都是值传递，对于表list是引用传递会改变原有变量的值。

面向对象

python使用类（class）和对象（object）进行面向对象编程，面向对象最主要的目的就是提高程序的重复使用性。
例:定义鸟类
class bird(object):
have_feather = ture
way_of_reproduction = ‘egg’
鸟类有两个属性，一是有无羽毛，一是生殖方式。

下面养一只小鸡 实体，起名summer
summer = bird（）
print summer.way_of_reproduction
其中第一句创建对象，第二句调用属性

动作

我们通过属性识别类别，有事也通过这个东西能做什么事情区分类别。比如，鸟会移动，就跟房屋区分开了，这些动作带来 一定的结果，比如导致位置的变化。
这些行为可以定义成方法（method）来使用
例：

class bird（object）： #object表示bird这个类 无父类，是最大的了，到头了
    have_feather  = ture
    way_of_reproduction = 'egg'
    def  move(self, dx, dy)
         position = [0, 0]
         position[0] = position[0] + dx
         position[1]  = position[1]  + dy
         return position
summer =  bird()
print 'after move:',summer.move(5, 8)

我们重新定义鸟类，增加了 一个表示移动的方法属性（方法参数中有一个self，是为了方便我们引用自身，方法的第一个参数必须是self 无论是否用到）
这样 小鸡summer可以跑了！

子类

类 本身还可以进一步细分成子类
比如，鸟类下还有大雁，鸡，鹅，麻雀。
在 oop中，通过继承（inheritance）来表达上述概念。
例：

class chicken(bird):    #括号里是bird表示这个chicken是bird的子类，有bird的所有属性
     way_of_move  =  'fly'    #移动方式是fly
     possible_in_kfc =  ture    #有可能进KFC
class oriole(bird):
    way_of_move =  'fly'   #移动方式是fly
    possible_in_kfc = false   #黄鹂鸟 绝不可能 进KFC
summer = chicken（）
print summer.have_feather
print summer.move(5, 8)

通过继承制度，减少程序中的重复信息和重复语句 ，面向对象提高了程序的可重复使用性。

调用类的其他信息

在定义方法时，必须有self这一参数，这个参数表示某个对象，对象拥有类 的 所有性质，那么我们 可以通过self，调用类属性。

class human（object）:
    laugh = 'hahahahaah'    #人有哈哈哈笑的属性
    def show_laugh(self):    #人有哈哈哈 笑的动作方法 
        print self.lauth			   #这个动作的内容就是调用人本身笑的属性print出来
    def laugh_100th(self):    #人有笑100次的方法
        for i in range(100):
        self.show_laugh()		#调用人笑的方法100次
 zrx = human()   #创建对象
 zrx.laugh_100th()  #调用对象方法

__init__方法
__init__是一个特殊方法。python有一些特殊方法，特点是名字前后有两个下划线。
如果在类中定义了__init__这个方法，创建对象时会自动调用，这也叫初始化。

class happybird(bird):
      def __init__(self,more_words):
          print 'we are happy birds.', more_words
summer  =happybird('happy,happy!')

屏幕打印：

we are happy birds.happy,happy!  #init自动调用

对象的性质

属性的值随着对象的不同而不同。
当定义类的方法时，必须要传递一个self参数。这个参数指代的就是类的一个对象，通过操纵self修改某个对象的值，通过赋值给self.attribute给这一对象增加一些性质。
例：

class human（object):
    def __init__(self,   input_gender):
         self.gender = input _gender
     def printgender(self)
         print  self.gender
zrx = human('male') 
print zrx.gender
zrx.printgender()

内置函数 dir()和help()

dir()用来查询一个类或者对象所有属性。
print dir(list)
help()用来查询说明文档。
print help(list）

list是python 内置的类
例：

n1 = [1, 2,  3, 4]
print  n1.count(5)    #计数，看有多少5
print n1.index(3)  	#查询 n1的第一个3的下标
n1.append（6）  	#在 n1的 最后增添一个新元素6
n1.sort（）				#对n1元素排序
print  n1.pop（）		#从n1中 去除最后 一个元素，并将该元素返回
n1.remove（2）     #从n1中去除第一个值为2的元素
n1.insert（0， 9）   #在下标为0的地方插入9

例：list相减

class superlist（list）：  #继承了list类
    def __sub__(self,b):	#原本就有的特殊函数，重新定义，dir(list)可见
        a  =  self[:]		#前一个list
        b = b[:]			#后一个list
        while len(b) > 0:   #当后一个list不为空时
            element_b = b.pop()			#取出后一个list最上方元素
            if  element_b in a:			#如果这个元素在前一个list中存在
                  a.remove(element_b)	#就删除
          return a
 print superlist([1,2,3]) -  superlist([3,  4])