Hello world程序输入和raw_input()内建函数注释运算符赋值运算符比较运算符逻辑运算符位运算成员运算符身份运算符变量和赋值数字字符串列表(List)和元组(Tuple)字典(dictionary)代码块及缩进对齐if语句while循环for循环与内建函数ange()列表推导式文件和内建函数open()、file()错误与异常函数类模块部分内建函数
Hello world
由于Python的简洁优雅，它输出Hello world只需要敲打出如下代码：
print('Hello world!')
# 或如下
myString="Hello world!"
print(mystring)
12345
程序输入和raw_input()内建函数
Python的raw_input()(Python 3.x 中变成了input)函数类似C++中的std::cin或是scanf.
user=raw_input('Please input yours name:')
1
如需查询内建函数的使用，或参数说明，输入如下代码：
help(raw_input)
1
核心风格：一直在函数外做用户交互
新手在作输出或输入操作时，容易直接使用print或raw_input进行操作。但函数一般情况应该只作输入参数，返回结果。从用户输入得到数据，调用函数进行输出
注释
Python中的注释类似Unix_shell中的风格，都是用#开始某行注释。
# 这里是注释
# 通常按照代码格式规范，会在#后边添加空格
12
而在Python中添加函数说明、类说明或是模块说明时通常使用DocString
# DocString存在一个惯例：
# 首行以英文字母大写开始（前提需要注释为英文），句号结束
# 然后空一行，第三行开始详细说明
def function():
'''这里时函数说明
这里是函数详细说明'''
12345678
运算符
和绝大多数变成语言一样，Python中的标准算术运算符以你熟悉的方式工作
# 加法
value=2 + 3
# 减法
value=3 - 2
# 乘法
value=3 * 2
# 乘方
value=3 ** 2 # 结果为 9
# 传统除法
value=2 / 4 # 结果为 0.5
# 浮点除法
value=2 // 4 # 结果为 0
123456789101112
赋值运算符
标识符描述=赋值+=加法赋值-=减法赋值=乘法赋值/=除法赋值%=取模赋值*=幂赋值//=取整赋值
比较运算符
标识符表达式的值>大于>=大于等于<小于<=小于等于==等于!=(或<>,不建议使用)不等于
逻辑运算符
标识符表达式的值and与or或not非
位运算
标识符表达式的值描述&与运算同时为1，则为1|或运算其中一个为1，则为1~非运算遇1为0^异或运算对立为0与1，则为1>>右移运算符右移指定位数<<左移运算符高位丢弃，低位补0
成员运算符
标识符描述in在列表中找到某值则返回Truenot in不在列表中则返回True
身份运算符
标识符描述isx is y类似id(x)==id(y),若引用的是同一个对象，则返回Truenot isx not is y 类似id(x)!=id（y）,若引用的不时同一对象，则返回True
核心风格：合理使用括号增强代码可读性，在很多场合使用括号都是一个好主意。
变量和赋值
Python是动态类型语言，也就是不需要预先声明变量的类型。变量类型在赋值的那一刻确定
数字
Python支持5种基本数字类型，其中三种是整形类型
int (有符号整形)long(长整形)bool(布尔值)float(浮点值)complex(复数值)
Python长整形表达的数值范围远远超过C/C++表示范围，事实上，长整形仅受限于用户计算机虚拟内存总数。类似Java的BigInteger。
长远看，int与long最终将融为一种数据类型，在Python2.3之前的版本中会出现的整数型溢出问题，之后已优化为自动转化为long数据类型。
而布尔类型，在参与与数字类型运算时True会当作1，False会当作0
其实还存在第6种数据类型decimal，用于十进制浮点数。不过它并非内建数据类型，需要导入模块decimal
字符串
Python中字符串被定义为引号之间的字符集合，其引号可以是单引号，双引号和三引号（可以用来包含特殊字符）
使用索引运算符[]和切片运算符[:]可以得到子串。
字符串特有的索引规则，第一个字符索引为0,最后一个字符索引为长度减1或-1
+ 号可用于连接字符串，* 可用于重复字符串
In [1]: mystring='Hello World'
In [2]: print(mystring)
Hello World
In [4]: print(mystring[0:5])
Hello
In [5]: print(mystring[0:5] * 3)
HelloHelloHello
In [6]: print(mystring[0:])
Hello World
In [7]: print(mystring[:-1])
Hello Worl
In [8]: print(mystring[:len(mystring)])
Hello World
In [10]: mystring + ',Hello China!'
Out[10]: 'Hello World,Hello China!'
In [12]: mystring='''python is \
...: so cool'''
In [13]: print(mystring)
python is so cool
12345678910111213141516171819202222232425262728
列表(List)和元组(Tuple)
列表与元组即数组，它可以容纳任意数量任意数据类型的Python对象。都可以利用索引访问其中的元素。
列表与元组的区别：
列表内容是用 [] 包裹或是声明，而元组是用 () 包裹或是声明列表元素的个数及其中的值可以改变，元组的个数和其中非引用类型值不可改变(只读)，若元组中包含某列表子项，则改变列表，相应元组中的列表也改变。都可以使用索引及切片得到子集
列表
# 列表推导式生成列表
In [34]: lst=[v for v in randint(10,size=10)]
In [35]: lst
Out[35]: [4, 3, 1, 7, 0, 4, 3, 7, 3, 5]
In [36]: lst[2:8]
Out[36]: [1, 7, 0, 4, 3, 7]
# 切片访问
In [40]: lst[2:-2]
Out[40]: [1, 7, 0, 4, 3, 7]
# 获得列表长度
In [41]: len(lst)
Out[41]: 10
# 索引访问
In [42]: lst[-2]
# 删除元素
Out[42]: 3
In [43]: del lst[2]
In [45]: print(lst)
[4, 3, 7, 0, 4, 3, 7, 3, 5]
# 删除间隔元素
In [46]: del lst[::2]
In [47]: print(lst)
[3, 0, 3, 3]
# 更多列表操作及成员方法使用以后章节详述
12345678910111213141516171819202222232425262728
元组
# 列表方式初始化元组
In [64]: tuples=tuple([ v for v in randint(10,size=10)])
In [65]: tuples
Out[65]: (8, 1, 6, 4, 9, 7, 4, 8, 9, 3)
In [66]: tuples[2]
Out[66]: 6
In [67]: tuples[2:6]
Out[67]: (6, 4, 9, 7)
# 尝试改变元组内子项，报错
In [68]: tuples[3]=5
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in ()
----> 1 tuples[3]=5
TypeError: 'tuple' object does not support item assignment
12345678910111213141516171819
字典(dictionary)
字典是Python中映射数据类型，工作原理类似Perl中的关联数组或者哈希表，由键-值（key-value）对构成
值可以是任意类型的Python对象，键必须为不可变类型
In [14]: dic={\
...: 0:'Monday',
...: 1:'Tuesday',
...: 2:'Wednesday',
...: 3:'Thursday',
...: 4:'Friday',
...: 5:'Saturday',
...: 6:'Sunday'
...: }
In [15]: dic
Out[15]:
{0: 'Monday',
1: 'Tuesday',
2: 'Wednesday',
3: 'Thursday',
4: 'Friday',
5: 'Saturday',
6: 'Sunday'}
In [16]: dic[6]
Out[16]: 'Sunday'
12345678910111213141516171819202222
代码块及缩进对齐
空白在Python中是很重要的。事实上行首空白非常重要，它称为缩进。在逻辑行首的空白（空格或制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。
逻辑行:Python的单个语句就是一个逻辑行
物理行:即肉眼所看到的一行
默认Python希望每个物理行只由一个逻辑行
如果希望某一物理行含有多个逻辑行（仅当此物理行语句过长时），请用分号（;）分隔每个逻辑行
强烈建议：每个物理行仅仅使用一个逻辑行，过长时，请使用行连接，即使用反斜杠（\）
这意味着同一层次的语句必须由相同的缩进。每一组这样的语句称为一个块。
缩进不规范将引发错误，如下例子：
introduction="I'm Quenwaz"
print introduction # 此语句将引发古董错误
print introduction
123
print(introduction) # 此语句将引发错误
^
IndentationError: unexpected indent
1234
如何缩进
不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。强烈建议 你在每个缩进层次使用 单个制表符 或 两个或四个空格 。
选择这三种缩进风格之一。更加重要的是，选择一种风格，然后一贯地使用它，即 只 使用这一种风格。
《简明 Python 教程》
if语句
标准if语句仅仅在格式上与C/C++语句上有所区别，即if空格后即是判定条件，冒号（：）结束条件判定，进入其子语句块。
格式如下：
if True:
print('Hello world！')
else:
print('Hello china')
1234
while循环
while循环类似if语句，注意各语句块缩进，格式如下：
while True:
print('Hello China!')
else:
print('Hello World!')
1234
for循环与内建函数ange()
Python中的for循环与传统的for循环不一样的地方，即它可以用来进行迭代序列或是迭代器。
如下迭代某列表：
In [4]: for item in ['e-mail', 'net-surfing', 'homework', 'chat']:
...: print(item)
...:
net-surfing
homework
chat
1234567
迭代某字符串
In [12]: str="I'm Quenwaz"
In [13]: for c in str:
...: print(c)
...:
I
'
m
Q
u
e
n
w
a
z
1234567891011121314151617
range内建函数
# range内建函数为左闭右开区间，第三各参数为步长，
# 步长设置为负数，则逆序
In [15]: for num in range(0,10,2):
...: print(num)
...:
0
2
4
6
8
In [16]: for num in range(0,10):
...: print(num)
...:
0
1
2
3
4
5
6
7
8
9
123456789101112131415161718192022222324
列表推导式
# 列表推导式请从for语句开始逻辑直到语句结束
# 再到列表开始直到for语句结束
In [21]: lst=[i * 2 for i in range(10)]
In [22]: lst
Out[22]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
123456
文件和内建函数open()、file()
如何打开文件
# open()第一个参数为文件路径，第二各参数为读写权限
# r 读取 w 写入 a 添加 b 表示二进制访问
# 若函数成功将返回文件句柄，之后对此文件的操作对针对此句柄展开
In [25]: handle=open('C:\Users\Quenwaz\Desktop\ est.png','r')
12345
其他文件属性，请自行查询相关文档，或者以如下方式查看对象属性：
In [29]: dir(handle)
Out[29]:
['_CHUNK_SIZE',
'__class__',
'__del__',
'__delattr__',
'__dict__',
'__dir__',
...
]
12345678910
或查看是否包含某属性
In [30]: hasattr(handle,'write')
Out[30]: True
12
错误与异常
编译时会检查语法错误，Python也允许再程序运行时检测错误。当检测到一个错误时，Python解释器就会引发异常，并显示异常详细信息。便于程序员快速定位修复。
需要给给代码添加错误检测或异常处理，需要添加try-except语句当中。
In [37]: try:
...: num=input('please input a number:')
...: num=int(num)
...: except ValueError:
# 抛出错误
...: print('input error')
...: finally:
# 不论是否执行成功，都需要执行finally语句块
...: print('finally output a value')
...:
please input a number:fdsa
input error
finally output a value
12345678910111213
函数
Python中的函数定义如下
In [39]: printValue('Hello Quenwaz!')
Hello Quenwaz!
In [42]: def returnValue(value):
...: return 2 * value
...:
In [43]: v=returnValue(100)
In [44]: v
Out[44]: 200
1234567891011
与其他编程语言一样，可以传参，与返回值
默认Python是通过引用调用，如果函数输入的是不可变数据类型，则函数按照值传递，若输入的是可变数据类型（如列表，字典等），则是引用传递。
其他函数可以默认传参，关键字传参等，后续章节将详述。
类
类是面向对象编程的核心，它扮演相关数据与逻辑的容器角色。它提供了创建“真实”对象的文凭蓝图。此处仅稍微讲解如何声明类。
class Person:
'''a Person class
'''
def __init__(self, age, sex, name):
'''初始化函数，类似构造函数
:param age: 年龄
:param sex: 性别
:param name: 名字
'''
self.name=name
self.age=age
self.sex=sex
def __del__(self):
'''类似析构函数，对象销毁时调用
:return:
'''
self.name=''
self.age=0
self.sex=''
def print_info(self):
print("我是%s,%s,今年%d岁" %(self.name, self.sex, self.age))
P=Person(18, '男性', 'Quenwaz')
P.print_info()
[out]:我是Quenwaz,男性,今年18岁
12345678910111213141516171819202222232425262728293031
什么是 self ? 它是类实例自身的引用。其他语言通常使用一个名为 this 的标识符。
模块
模块是一种组织形式，它将有联系的Python代码组织到一个独立文件中。模块可包含可执行代码，函数或类。
如何导入一个模块
# 此处导入内置模块sys与time
import sys, time
# 导入后可直接用模块名调用其内部函数或变量以及类
In [3]: import sys, time
In [4]: print(sys.platform)
win32
In [5]: print(time.localtime)
# 或是将导入的模块取一个别名
In [7]: import time as tm
In [8]: tm.localtime
Out[8]:
1234567891011121314151617
部分内建函数
函数描述dir([obj])显示对象的属性列表，如果没有提供参数，将返回全局变量的名字。help([obje])以一种整齐美观的形式显示对象的文档字符串。若不提供任何参数，将进入交互式帮助界面。int(obj)将一个对象转换成整形len(obj)返回对象的长度open(fn, mode)以mode(‘r’=读 ‘w’=写)方式打开一个名字为fn的文件range(start:int,stop:int,step:int=1)返回一个左闭右开的列表，步长为stepinput(str)等待用户输入一个字符串，其中str参数为提示字符串str(obj)将一个对象转换成字符串type(obj)返回对象类型。