#!/usr/local/bin/python2.7
# coding:utf-8
#
#输入和raw_input(),raw_input()是个内建的函数。它读取标准输入，并将去到的数据复制给指定的变量
#user = raw_input('Enter login name:')
#print 'Your login is:',user

#%d %s %f   十进制  字符串  浮点型
#下面这个例子是打印浮点数，整数型的
#[root@localhost python]# cat a.py
#!/usr/local/bin/python2.7
# coding:utf-8
#输入和raw_input()
#user = raw_input('Enter login name:')
#print 'Your login is: %d' % (int(user) * 2)
#print 'Your login is: %f' % (int(user) * 2)
#print 'Your login is: %s' % (int(user) * 2)
#print 'Your login is: %f',user
#print 'Your login is: %c',user
#print 'Your login is: %a',user
#print 'Your login is: %s',user
#[root@localhost python]# python a.py
#Enter login name:22
#Your login is: 44
#Your login is: 44.000000
#Your login is: 44
#Your login is: %f 22
#Your login is: %c 22
#Your login is: %a 22
#Your login is: %s 22

#操作符，这类的操作符之前还真没有认真看过，这回一定要好好做笔记，那么有什么区别了？之前只知道一个/单斜杠是除号，而不知道双斜杠，单斜杠是传统除法而双斜杠是浮点数型的，且对结果进行四舍五入。
#>>> print -2*4 + 3*2
#-2
#>>> print -2*4 + 3**2
#1
#正如上面的例子，我们知道了双星号跟单个还是有差别的这里我们可以想象到双星号是乘方的作用了，这里有学到了点新知识，书还是多看点 好，笔记多做的好。

#接下来比较操作符了，比较操作符没啥新知识，去掉吧

#2.5 变量和赋值，去尼玛的蛋
#2.6. 数字 python支持五种数字类型，其中有三种是整型类型
#有符号整型 长整型 布尔型 浮点值 复数
#int 002 22
#long 22222222222222222L -2222 0XDECADEDDDAFEAFEAE
#bool True False
#float 3.151111 4.2E-10  -90. 6.00223e22 -l.233e-19
#complex 6.23+1.5j  -1.23-5434j 0+1j 9.6323-56.222j

#2.7 字符串 python字符串被定义为引号直接的字符集合。python支持使用承兑的单引号或双引号，三引号可以用来包含特色字符。
#2.8 列表和索引
#这节的基础知识，不管懂不懂都要记录下来啊。可以当成普通的数组，能保存任意数量任何类型的python对象，懂了吗？这里第一次提到了对象。python一切皆对象的本质体现出来了吧？这个还要class来定义对象吗？
#可以像数组一样访问元素，但是列表和元祖存储不同类型的对象
#列表和元祖的差别：
#列表用中括号包裹，元素个数和值可以改变
#元祖用小括号报告，不可以更改
#相同点：可以通过切片运算得到子集[] 和[:]
#>>> aList = [1,2,3,4]  #创建一个列表aList
#>>> aList        #打印列表aList
#[1, 2, 3, 4]
#>>> aList[2]    #打印第三个元素
#3
#>>> aList[2:] #打印第三个元素之后的所有元素
#[3, 4]
#>>> aList[:2]    #打印前两个元素即第三个元素之前的元素
#[1, 2]

#>>> aTuple = ('robots',33,42,'try')
#>>> aTuple
#('robots', 33, 42, 'try')
#>>> aTuple[:2]
#('robots', 33)
#>>> aTuple[2]
#42
#>>> aTuple[1] = 1
#Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
#TypeError: 'tuple' object does not support item assignment
#

#字典作用是映射数据类型由键-值（key-value）对构成
#机会所有类型的python对象都可以用做键，
#>>> aDict = {'host':'earth'}  #创建一个名称为aDict的字典
#>>> aDict = ['port'] = 80        #往字典里面添加一个元素port = 80 这里我添加错了，多了个等号，天才是怎样炼成的？
#  File "<stdin>", line 1
#SyntaxError: can't assign to literal  #明显的语法错误啊
#>>> aDict ['port'] = 80        #再添加一次，成功了吧
#>>> aDict                        #打印字典
#{'host': 'earth', 'port': 80}
#>>> aDict.keys()                #调用keys方法
#['host', 'port']
#>>> aDict['host']
#'earth'                
#>>> for key in aDict:        #这里报错了，不知道为何
#... print key,aDict[key]
#  File "<stdin>", line 2
#    print key,aDict[key]
#        ^
#IndentationError: expected an indented block
#>>> for key in aDict:
#... print key, aDict[key]
#  File "<stdin>", line 2
#    print key, aDict[key]
#        ^
#IndentationError: expected an indented block

#接下来就是循环了。基础不能错过
#if x < .0:
#    print "x" must be atleast 0!
#else语句
#if expression:
#    if_suite
#else:
#    else_suite
#还支持elif语句，语法如下
#if expression1:
#    if_suite
#elif expression2:
#    elif_suite
#else:
#    else_suite
#while循环
#标准while条件循环语句的语法类似if。
#while expression:
#    while_suite
#语句 while_suite会被连续不断的循环执行，直接表达式的值编程0或者false。
#[root@localhost python]# cat b.py
#!bin/python
#counter = 0
#while counter < 3:
#        print 'loop #%d' % (counter)
#        counter +=1
#[root@localhost python]# python b.py
#loop #0
#loop #1
#loop #2
#基础知识巩固之：什么是属性？属性是与数据有关的项目。属性可以是简单的数据值，也可以是可执行对象，比如函数和方法。那些对象有用属性了？类，模块，文件和复数等对象都拥有属性使用句点属性标识符。也就是说对象名称和属性名称直接加一个句号object.attribute
#
#文件和内建函数 open(),file()
#错误和异常，没有特别说明的，坑跳多了也就会了
#函数 python函数使用小括号调用。函数在调用之前必须定义。如果函数中没有return语句，就会自动返回None对象
#如何定义函数：def function_name([arguments]):
#                    "optional documentation string"
#                    function_suite
#定义一个函数的语法由def关键字及紧随其后的函数名，再加上该函数需要的几个参数组成。函数参数可以选的，以冒号结尾： 之后代表函数体的代码组
#def addMe2Me(X):
#    'apply + operation to argument'
#    return (x+x)
#上面函数已经定义了，如何调用了？
#addMe2Me(22.2)
#>>> addMe2Me
#<function addMe2Me at 0x01C9DD30>
#>>> print addMe2Me
#<function addMe2Me at 0x01C9DD30>
#>>> addMe2Me(22.2)
#44.4
#>>> addMe2Me(10)
#20
#>>> addMe2Me('python')
#'pythonpython'
#>>> addMe2Me([-1,'abc'])
#[-1, 'abc', -1, 'abc']
#
#默认参数
#def foo(debug=True):
#    if debug:
#        print 'in debug mode'
#    print 'done'
#>>> foo()
#in debug mode
#done
#>>> foo(True)
#in debug mode
#done
#>>> foo(False)
#done

无论是python自带的IDLE编辑器还是最sublime编辑器，各有各自的特点，当然基于xypython的spe也有很多好处

各自有自己的好处，此处省略一万字

感觉在xypython调试代码比较人性化，特别是在操作数据库的时候感觉非常棒滴

有时候感觉IDLE中比较好。

而sublime就感觉比较鸡肋了,不过有代码补全功能，写代码还是不错的，也有报错提示。总之写代码靠他，调试还是不要用它了

python之数据结构，好几天没有坚持了，以后很少挂QQ

python之数据结构，好几天没有写程序了。蛋疼，都是在扯淡

数据结构：数据结构就是通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合，这些数据元素可以是数字或者字符甚至额可以是其他数据结构，python中，最基本的数据结构是序列 。序列中的每个元素被分配一个序号—即元素的位置，也成为索引。

python中有六种内建的序列：暂时学习两种，列表和元祖
其他序列有：字符串，，unicode字符窜，buffer对象和xrange对象

列表和元祖的区别在于，列表可以修改，而元组不行。

通用序列操作：
所有序列都可以精心某些特定的操作。包括：索引(indxing),分片(sliceing),加(adding),乘(multiplying)以及检查某个元素是否属于序列的车呢国有(成员资格)。

序列中的所有元素都是有编号的–从0开始递增。这些元素可以通过编号分别访问，如下例所示：
>>> greeting = ‘Hello’
>>> greeting[0]
‘H’
>>> greeting[2]
‘l’
>>> greeting[-1]
‘o’

分片：
与使用索引来访问单个元素类似，可以使用分片操作来访问一定范围的元素。分片通过冒号像个的两个索引来实现：

前面学习了很多知识，都是注释的，现在就不注释了，也不会贴什么图片装逼，不写注释好代码补全打字速度上去了

第三章 python语法
介绍python一些基本编程风格，之后简要介绍标识符，变量和关键字。
3.1语句和语法
python 语句中有一些基本规则和特殊字符：
井号之后为注释#
#换行(\n) 是标准 的换行符，（通常一个语句一行）
反斜线 \继续上一行，跟Linux的很像啊
分号，将两个语句链接在一行中
冒号 将代码块的头和体分开
语句（代码块）用缩进方式体现
不同的缩进深度分隔不同的代码块
python文件以模块的形式组织

3.16 模块

3.2变量赋值
python中等号是主要的赋值操作（其他是增量赋值操作）
赋值并不是直接将一个值赋给一个变量，尽管你可能根据其他语言编程经验认为应该如此。
在python中，对象是通过引用传递的。在赋值的时候，不管这个对象是新建的还是已经存在的都是将该对象的引用（并不是值）赋值给变量。
第四章：对象

所有python对象都拥有三个特性：身份，类型和值
身份： 每个对象都有一个唯一 的身份标识自己，任何对象的身份可以使用内建函数id()来得到。
   这个值可以被认为是该对象的内存地址。你极少会用的哦啊这个值，也不用太关心它研究是什么
类型：对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。你可以用内建函数type()查看python对象的类型。因为在python中类型也是对象
值：对象表示数据项

对象属性：
某些python对象属性，值或相关联的可执行代码，比如方法（method），python用句点标记法来访问属性。最常用的属性是函数和方法，含有数据属性的对象包括：类，类实例，模块，复数和文件
4.2 标准类型
数字：分为几个子类型，其中三个是整型
integer整型
boolean 布尔型
long integer 长整型
floating point real number 浮点型
string     字符串
list 列表
tuple 元组
dictionary 字典
其他内建内型
类型 null对象（none）  文件 集合/固定集合 函数/方法 模块 类

标准类型内建函数
cmp(obj1,obj2) 根据比较结果返回整型i：
               i < 0 if obj1 <obj2
               i > 0 if obj1 >obj2
               i == 0 if obj1 == obj2
repr(obj)或者'obj'    返回一个对象的字符串表示
str(obj)    返回对象适合可读性好的字符串表示
type(obj)    得到一个对象的类型，并返回相应的type对象

type() 是内建的函数2.2后变成"工厂函数"了，那么我们该怎么理解工厂函数了？
>>> type(2)
<type 'int'>
>>> type('hello world!')
<type 'str'>
>>> type(type)
<type 'type'>

多的我就懒得打字了。直接上代码看cmp()
>>> a,b = 2,11
>>> cmp(a,b)
-1
>>> cmp(b,a)
1
>>> a = 11
>>> cmp(a,b)
0
>>> cmp(b,a)
0

>>> c,d = 'abc','wcx'
>>> cmp(c,d)
-1
>>> cmp(d,c)
1
>>> d =  'abc'
>>> cmp(c,d)
0

str() repr()操作符
str() repr() 或反引号操作符('')可以方便地以字符串的方式获取对象的内容。类型，数值属性等信息

str() 函数得到的字符串可读性好，而repr()函数得到的字符串通常可以用来重新获得该对象，通常情况下obj == eval(repr(obj)) 这个等式是成立的。

>>> str(1.22-2j)
'(1.22-2j)'
>>> str(2)
'2'
>>> exit()
[root@localhost ~]# python2.7
Python 2.7.5 (default, Mar 18 2014, 05:37:40)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-54)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> str(2.23-2j)
'(2.23-2j)'
>>> str(2e10)
'20000000000.0'
>>> str([3,1,4,66])
'[3, 1, 4, 66]'
>>> '[2,4,1,55]'
'[2,4,1,55]'

>>> for i in range(1,20):
   r = random.randint(1,100)
   position = bisect,bisect(l,r)
   bisect.insort(l,r)
   print '%2d %2d' % (r,position),l

Traceback (most recent call last):
 File "<pyshell#21>", line 3, in <module>
   position = bisect,bisect(l,r)
TypeError: 'module' object is not callable

^
>>> for i in range(1, 20):
   r = random.randint(1, 100)
   position = bisect.bisect(l, r)
   bisect.insort(l, r)

接下来第六章了，第五章以后慢慢看，不是以后，现在有时间就看看这里的内容。离开网络才能认真的学习啊。深有体悟

第六章 序列：字符串，列表和元组
一：序列
1.序列的介绍
序列的定义：成员有序排列，并且可以通过下班偏移量访问到它的一个或者几个成员，这类python类型统称为序列，包括字符串，列表和元组类型

接下来的东西感觉有点乱，不容易接受，好好总结一下。
是不是python讲的太多对象了？什么地方译者都搞个类型出来忽悠我们？
那么我自己来理解吧

序列就序列了，还整个序列类型，这里我喷死那个译者，字符串后面非得加个类型你拓麻的才爽啊，尼玛祖传类型。

序列有哪些了？前面讲到的字符串，列表和元组，哥少写了几个类型感觉爽多了

序列有着相同的访问模式：它的每一个元素可以通过制定一个偏移量的方式得到。而多个元素可以通过切片操作的方式得到，切片操作会在接下来的内容中讲到。下标偏移量是从0开始到总元素-1结束——之所以要减1，是因为我们从0开始啊。

标准类型操作符
适用于所有序列类型（这里说序列类型还像话）这里他说参考4.5节，批评一句语病（不过其他的操作绝对是完全适用的），初三的学生看了都头疼。

我真是纳闷，这章作者为什么不译成 序列类型：字符串类型，列表类型和元组类型

序列操作符：
1，成员关系操作符（in, not in）
成员关系才哦啊佐夫是用来判断一个元素是否属于一个序列的。对于字符串来说，判断这个字符是否属于字符串；对于元组来说，就代表了一个对象是否属于该对象序列。in/not in 的操作符返回值一般来讲就是True/Flase满足成员关系就返回True，否则返回Flase操作语法如下
对象 [not] in 序列

序列操作符
序列操作符                 作用
seq[ind]            活动下标为ind的元素
seq[ind1:ind2]        活动下标从ind1到ind2间的元素集合
seq*expr             序列从父expre次
seq1+seq2            里那句seq1和seq2
obj in seq             判断obj元素是否包含在seq中

2.连接操作符(+)
这个操作符允许我们把一个序列和另外一个相同序列的类型做连接。语法如下。
sequence1 + sequence2
该表达式的结果是一个包含sequencel和sequence2 的内容的新序列。

3.重复操作符*
这里前面有讲到过的不再写了，自己多看吧。前四章是基础，大概把前十章的内容都给说了一遍。

4.切片操作符([],[:],[::])
简单地讲，所谓序列类型就是包含一些序列排列的对象的一个结构。你可以简单的用方括号加一个下标的方式访问它的每一个元素，或者通过在方括号中用冒号把开始下标和结束下标分开的方式来访问一组连续的元素。

看到这里头疼，读译者的文字感觉很累。看其他书去了补充这里遗漏的

5.
6.13 内建函数
标准内建函数
cmp()
>>> list1,list2 = [123,'xy2'],[234,'abc']
>>> cmp(list1,list2)
-1
>>> cmp(list2,list1)
1
>>> list3 = list2 + [567]
>>> list3
[234, 'abc', 567]
>>> cmp(list2,list3]
SyntaxError: invalid syntax
>>> cmp(list2,list3)
-1

len()
对字符串来说，返回字符串长度的个数，对于元组和列表来说，它会返回列表和元组的元素个数。容器中的每个对象被作为一个项来处理
用上面例子和新定义一个字符串list4来举例

>>> len(list2)
2
>>> len(list3)
3
>>> len(list1)
2
>>> list4 = 'abcdef2d'
>>> len(list4)
8

max() min()
在字符串中作用不大

sorted() 和 reversed()
>>> s = ['They','stamp','them','when',"they'er",'smaill']
>>> for t in reversed(s):
   print t,

smaill they'er when them stamp They
>>> sorted(s)
['They', 'smaill', 'stamp', 'them', "they'er", 'when']
>>>

4.元组

接下来元祖了，可能没有章序，不过以后会好好整，慢慢来

1.如何创建一个元组并给它赋值
这里我建议要用例子上面的桥，数字字母可以乱写，不过要想想作者为什么这么写？有什么规律。作者命名的时候并不是乱命名的，而是有规律可言的。学习一定要认真，态度一定要端正

>>> aTuple = (123,'abc',3.21,['inner','tuple'],7-9j)>>> aontherTuple = (None,'something to see here')
>>> print aTuple
(123, 'abc', 3.21, ['inner', 'tuple'], (7-9j))
>>> print anotherTuple
(None, 'something to see here')

>>> a = (None)
>>> print a
None
>>> b = (None,)
>>> print b
(None,)
>>> tuple('bar')
('b', 'a', 'r')

访问元组中的值
元组切片操作跟列表一样，用方括号作为切片操作符([]),里面写上索引或者索引范围

>>> aTuple[2:4]
(3.21, ['inner', 'tuple'])
>>> aTuple[0:3]
(123, 'abc', 3.21)
>>> aTuple[2][0]

Traceback (most recent call last):
 File "<pyshell#14>", line 1, in <module>
   aTuple[2][0]
TypeError: 'float' object has no attribute '__getitem__'
>>> aTuple[3][1]
'tuple'
>>> aTuple[3][2]

Traceback (most recent call last):
 File "<pyshell#16>", line 1, in <module>
   aTuple[3][2]
IndexError: list index out of range
>>> aTuple[:2]
(123, 'abc')
>>>

如何更新元组

不可以改变的，可以重新构造一个啦

例如

>>> aTuple = aTuple[0],aTuple[2],aTuple[-1]
>>> aTuple
(123, 3.21, (7-9j))
原来我们定义的aTuple是什么了？下面的啦
>>> aTuple = (123,'abc',3.21,['inner','tuple'],7-9j)
>>> print aTuple
(123, 'abc', 3.21, ['inner', 'tuple'], (7-9j))

就这样就得到了一个新的元组，感觉有点坑不？