hello word！
脚本helloword.py
#!/usr/bin/env python print('Hello World!')
两种执行方式：
1. $python helloword.py
Hello World!
2. $./ helloword.py
Hello World!
注意：脚本首行就是给执行方式2，指定解释器；就和写shell 脚本时首行指定 bash一样；
如果用第一种方式，执行。首行不写也可以正确执行噢！通常情况还是要写上去的；
基本数据类型
变量不需要声明
>>>a = 10 >>>print a >>>print type(a)
输出会如下：
10
<type 'int'>
这里要注意的是内置函数 type()查询变量的类型；
当然变量不需要声明，所以当你想在a中放入其他类型数据也是可以的噢；
>>>a = 1.3
>>>print a,type(a)
输入如下：
1.3 <type 'float'>
序列 sequence
sequence是一组有顺序的元素的集合；
序列有两种：tuple(定值表；也有翻译为元祖) 和list（表）
>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False) # s1是一个tuple >>>s2 = [True, 5, 'smile'] # s2是一个list >>>print s1,type(s1) >>>print s2,type(s2)
输出：
(2, 1.3, 'love', 5.6, 9, 12, False) <type 'tuple'>
[True, 5, 'smile'] <type 'list'>
注意：tuple 与 list 的区别是tuple 在给定之后不可改；而list可更改
判定是tuple，或者 list 是通过（）和[]来判定的噢！
一个序列作为另一个序列的元素
>>>s3 = [1,[3,4,5]]
空序列
>>>s4 = []
序列元素的引用更改：
序列的引用通过s[<int>]实现， int为下标s为序列符号
例如上面：取s1 的第二个元素 s2的第三个元素
>>>print s1[1] 1.3 >>>print s2[2] smile >>>print s3[1][2] #有点二维数组的味道 5
注意：下标也是从0开始的噢；
其他引用方式：
范围引用： 基本样式[下限:上限:步长]
重点：不包括上限元素本身噢，如果有上限；
>>>print s1[:5] # 从开始到下标4 （下标5的元素 不包括在内） >>>print s1[2:] # 从下标2到最后 >>>print s1[0:5:2] # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素） >>>print s1[2:0:-1] # 从下标2到下标1
尾部元素引用
>>>print s1[-1] # 序列最后一个元素 >>>print s1[-3] # 序列倒数第三个元素
同样，如果s1[0:-1], 那么最后一个元素不会被引用 （再一次，不包括上限元素本身）
字符串是一个tuple；
字符串是一种特殊的元素，因此可以执行元组的相关操作
>>>str = 'abcdef' >>>print str[2:4]
运算
数学运算
>>>print 1+9 # 加法
>>>print 1.3-4 # 减法
>>>print 3*5 # 乘法
>>>print 4.5/1.5 # 除法
>>>print 3**2 # 乘方
>>>print 10%3 # 求余数
判断返回True/False
>>>print 5 in [1,3,5] # 5是list [1,3,5]的一个元素
==, !=, >, >=, <, <=, in
逻辑运算
and, or, not 与或非
缩进和选择
Python最具特色的是用缩进来标明成块的代码；
用缩进空格来表示隶属关系；
if语句之后的冒号
以四个空格的缩进来表示隶属关系, Python中不能随意缩进
if <条件1>:
statement
elif <条件2>:
statement
elif <条件3>：
statement
else:
statement
循环
for循环
基本构造是
for 元素 in 序列:
statement
statement
举例：
for a in [3,4.4,'life']:
print a
打印这个list中每一个元素；
range()，函数来建list表；
idx = range(5)
print idx
输出：
[0, 1, 2, 3, 4]
这个函数的功能是新建一个表。这个表的元素都是整数，从0开始，下一个元素比前一个大1， 直到函数中所写的上限 （不包括该上限本身）
举例：
for a in range(10):
print a**2
print a**2
while循环
while 条件:
statement
statement
while会不停地循环执行隶属于它的语句，直到条件为假(False)
举例
while i < 10:
print i
i = i + 1
print i
i = i + 1
中断循环
continue # 在循环的某一次执行中，如果遇到continue, 那么跳过这一次执行，进行下一次的操作
break # 停止执行整个循环
举例
for i in range(10):
if i == 2:
continue
if i == 2:
continue
print i
输出除2以外的0-9；
for i in range(10):
if i == 6:
break
print i
输出0-5,6的时候已经跳出所以不输出；
函数
函数最重要的目的是方便我们重复使用相同的一段程序。
函数的定义
def square_sum(a,b):
c = a**2 + b**2
c = a**2 + b**2
return c
这个函数的功能是求两个数的平方和。
首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。
括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）
c = a**2 + b**2 # 这一句是函数内部进行的运算
return c # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。
return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。
return a,b,c # 相当于 return (a,b,c)
函数参数的传递
变量传递是值传递
表传递是 地址传递
面向对象的基本概念
Python使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程
相近对象归为类
定义鸟类：
class Bird(object): have_feather = True way_of_reproduction = 'egg'
创建对象
summer = Bird() print summer.way_of_reproduction
可怜的summer，你就是个有毛产的蛋货，好不精致。
动作
class Bird(object): #object说明Bird类没有父类
have_feather = True 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，无论是否用到。
dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。
在最后调用move方法的时候，我们只传递了dx和dy两个参数，不需要传递self参数（因为self只是为了内部使用）
我的summer可以跑了。
子类
类别本身还可以进一步细分成子类比如说，鸟类可以进一步分成鸡，大雁，黄鹂。
在OOP中，我们通过继承(inheritance)来表达上述概念。
class Chicken(Bird): way_of_move = 'walk' possible_in_KFC = True class Oriole(Bird): way_of_move = 'fly' possible_in_KFC = False summer = Chicken() print summer.have_feather print summer.move(5,8)
新定义的鸡（Chicken）类的，增加了两个属性：移动方式（way_of_move），可能在KFC找到（possible_in_KFC）
在类定义时，括号里为了Bird。这说明，Chicken是属于鸟类（Bird）的一个子类，即Chicken继承自Bird。自然而然，Bird就是Chicken的父类。Chicken将享有Bird的所有属性。
尽管我只声明了summer是鸡类，它通过继承享有了父类的属性（无论是变量属性have_feather还是方法属性move）
注意：若定义类是括号中为object则该类没有父类；
self
定义类的方法是，必须有self，这个参数表示某一具体的对象；可以通过self,调用类的属性；对象的性质，也是通过self来改变的。
class Human(object): def __init__(self, input_gender): self.gender = input_gender def printGender(self): print self.gender li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的input_gender变量。 print li_lei.gender li_lei.printGender()
__init__()方法
是一个特殊的方法，python有一些特殊的方法，python会特殊的对待他们。特殊方法的特点是前后有两个下划线。
例子：
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__()方法，是初始化的过程；python在创建对象时，自动调用这个方法，这个过程叫做初始化的过程。
everything is object
dir()
查询一个类或者对象所有属性
help（）
查询说明文档
list是一个类，是python已经定义好的一个类，当我们新建一个表时，如：
>>>nl = [1,2,5,3,5]
实际上，n1是类list的一个对象
那么list既然是一个类，那我们n1对象就可以调用它的方法：
>>>print nl.count(5) # 计数，看总共有多少个5 >>>print nl.index(3) # 查询 nl 的第一个3的下标 >>>nl.append(6) # 在 nl 的最后增添一个新元素6 >>>nl.sort() # 对nl的元素排序 >>>print nl.pop() # 从nl中去除最后一个元素，并将该元素返回 >>>nl.remove(2) # 从nl中去除第一个2 >>>nl.insert(0,9) # 在下标为0的位置插入9
运算符是特殊方法
使用dir(list)的时候，能看到一个属性，是__add__()。从形式上看是特殊方法（下划线，下划线）。
它特殊在哪呢？这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行的操作。
>>>print [1,2,3] + [5,6,9]
运算符，比如+, -, >, <, 以及下标引用[start:end]等等，从根本上都是定义在类内部的方法。
尝试一下
>>>print [1,2,3] - [3,4]
会有错误信息，说明该运算符“-”没有定义。现在我们继承list类，添加对"-"的定义
class superList(list): def __sub__(self, b): a = self[:] # 这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。 b = b[:] while len(b) > 0: element_b = b.pop() if element_b in a: a.remove(element_b) return a print superList([1,2,3]) - superList([3,4])
内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。
总结
- 内置函数type(),查询变量类型
- 序列sequence
- 区别tuple,不可更改，list可更改
- tuple用小括号，list用中括号
- tuple: 定值表(元组)
- s1=(2,1.3,'love',False,12)
- list：表
- s1=[Ture,5,'simple']
- s1[1]值为5
- s3=[1,[2,3,4]]
- s3[1][0]值为2
- s1=[Ture,5,'simple']
- 引用方式
- [下限:上限:步长]
- 注意如果有上限，是不含上限本身的。
- s1[:5] # 从开始到下标4 （下标5的元素 不包括在内）
- s1[2:] # 从下标2到最后
- s1[0:5:2] # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）
- s1[2:0:-1] # 从下标2到下标1
- 尾部元素引用
- s1[-1] # 序列最后一个元素
- s1[-3] # 序列倒数第三个元素
- [下限:上限:步长]
- 字符串是一个tuple，因此也使用上面引用方式
- 判断返回
- print 5 in [1,3,5]，返回TRUE
- 语法
- 使用缩进表示隶属关系
- if <condition>: 注意冒号
- 循环
- for 元素 in 序列: 注意冒号
- range()函数来建立list表
- while
- 函数
- def squeare_sum(a,b):
- 面向对象
- 定义类->创建对象->对象引用类属性
- 类中的方法第一个参数必须是self,无论是否用到。方便自身引用。
- object作为没有父类的 类
- __init__()方法，是初始化的过程；python在创建对象时，自动调用这个方法，这个过程叫做初始化的过程。
- dir():查看对象或者类的所有属性；
- help():查看类或对象的帮助信息；
- list类的方法
- >>>print nl.count(5) # 计数，看总共有多少个5
- >>>print nl.index(3) # 查询 nl 的第一个3的下标
- >>>nl.append(6) # 在 nl 的最后增添一个新元素6
- >>>nl.sort() # 对nl的元素排序
- >>>print nl.pop() # 从nl中去除最后一个元素，并将该元素返回
- >>>nl.remove(2) # 从nl中去除第一个2
- >>>nl.insert(0,9) # 在下标为0的位置插入9
- 如果属性或方法已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。