Python 的运行环境（IDE）是IDLE GUI 在shell 里面运行。
Python中整数溢出的问题解决，计算结果后面有一个数字L
可以用一个命令：type(object)来检测一个数是什么类型。
e.g
>>> type(4)
<type 'int'> #4是int，整数
>>> type(5.0)
<type 'float'> #5.0是float，浮点数
type(988776544222112233445566778899887766554433221133344455566677788998776543222344556678)
<type 'long'> #是长整数，也是一个整数
几个常见的函数
1 求绝对值
>>> abs(10)
10
>>> abs(-10)
10
>>> abs(-1.2)
1.2
2四舍五入
>>> round(1.234)
1.0
>>> round(1.234,2)
1.23
>>> #如果不清楚这个函数的用法，可以使用下面方法看帮助信息
>>> help(round)
Help on built-in function round in module __builtin__:
round(...)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).
This always returns a floating point number. Precision may be negative
3幂函数
>>> pow(2,3) #2的3次方
8
4 math 模块
>>> import math #引入math模块
>>> math.floor(32.8) #取整，不是四舍五入
32.0
>>> math.sqrt(4) #开平方
2.0
引用模块解决除法--启用轮子
形式1：import module-name。import后面跟空格，然后是模块名称，例如：import os
形式2：from module1 import module11。module1是一个大模块，里面还有子模块
module11，只想用module11
>>> from __future__ import division
>>> 5/2
2.5
>>> 9/2
4.5
>>> 9.0/2
4.5
>>> 9/2.0
4.5
引用了一个模块之后，再做除法，就不管什么情况，都是得到浮点数的结果了。
这就是轮子的力量
关于余数
用 % 符号来取得两个数相除的余数.
e.g.
>>> 5%2
1 >
>> 9%2
1 >
>> 7%3
1 >
>> 6%4
2 >
>> 5.0%2
1.0
函数divmod
>>> divmod(5,2) #表示5除以2，返回了商和余数
(2, 1)
>>> divmod(9,2)
(4, 1)
>>> divmod(5.0,2)
(2.0, 1.0)
四舍五入round()
>>> round(1.234567,2)
1.23
>>> round(1.234567,3)
1.235
>>> round(10.0/3,4)
3.3333
当你遇到下面的情况，就有点怀疑了：
>>> round(1.2345,3)
1.234 #应该是：1.235
>>> round(2.235,2)
2.23 #应该是：2.24
程序。
程序，简而言之，就是指令的集合。但是，有的程序需要编译，有
的不需要。python编写的程序就不需要，因此她也被称之为脚本程序
CMD中输入cd..回退到C盘，直接输入D:跳到D盘 然后dir回车就可以看到D盘的文件目录
cd+文件夹名称 表示跳到该文件下
安装：设置环境变量 win10 系统---高级设置---高级设置---环境变量---双击path 最后面加上;C:\Python27\ 进入cmd 输入python就ok
IDE的信息，推荐阅读维基百科中的词条
英文词条：Integrated development environment
解一道题目
请计算：19+2*4-8/2
代码如下：
#coding:utf-8
"""
请计算：19+2*4-8/2
"""
a = 19+2*4-8/2
print a
在shell或者cmd中，执行：python (文件名.py)
上面代码中，第一行，不能少，本文件是能够输入汉字的，否则汉字无法输入
变量本质——占位符
就是先把那个位置用变量占上，表示这里有一个东西，至于这个位置放什么东西，以后再说，反正先用一个符号占着这个位置（ 占位符）
建立实用的函数
上面用命令方式建立函数，还不够“正规化”，那么就来写一个.py文件吧。
在IDLE中，File->New window
然后输入如下代码：
#coding:utf-8
def add_function(a,b):
c = a+b
print c
if __name__=="__main__":
add_function(2,3)
#coding:utf-8声明本 文件中代码的字符集类型是utf-8格式。初学者如果还不理解，一方
面可以去google，另外还可放一放，就先这么抄写下来，以后会讲解。
def add_function(a,b): 这里是函数的开始。在声明要建立一个函数的时候，一定要使用
def（ def 就是英文define的前三个字母） ，意思就是告知计算机，这里要声明一个函数；
add_function是这个函数名称，取名字是有讲究的，就好比你的名字一样。在python中取
名字的讲究就是要有一定意义，能够从名字中看出这个函数是用来干什么的。从
add_function这个名字中，是不是看出她是用来计算加法的呢？(a,b)这个括号里面的是这
个函数的参数，也就是函数变量。冒号，这个冒号非常非常重要，如果少了，就报错
了。冒号的意思就是下面好开始真正的函数内容了。
c=a+b 特别注意，这一行比上一行要缩进四个空格。这是python的规定，要牢记，不可
丢掉，丢了就报错。然后这句话就是将两个参数(变量)相加，结果赋值与另外一个变量
c。
print c 还是提醒看官注意，缩进四个空格。将得到的结果c的值打印出来。
if name=="main": 这句话先照抄，不解释。注意就是不缩进了。
add_function(2,3) 这才是真正调用前面建立的函数，并且传入两个参数：a=2,b=3。仔细
观察传入参数的方法，就是把2放在a那个位置，3
声明函数的格式为：
def 函数名(参数1，参数2，...，参数n)：
函数体
python对命名的一般要求。
文件名:全小写,可使用下划线
函数名:小写，可以用下划线风格单词以增加可读性。如：myfunction，
my_example_function。注意：混合大小写仅被允许用于这种风格已经占据优势的时候，
以便保持向后兼容。
函数的参数:如果一个函数的参数名称和保留的关键字(所谓保留关键字，就是python语言
已经占用的名称，通常被用来做为已经有的函数等的命名了，你如果还用，就不行了。)
冲突，通常使用一个后缀下划线好于使用缩写或奇怪的拼写。
变量:变量名全部小写，由下划线连接各个单词。如color = WHITE，this_is_a_variable =1
在python中有一种方法专门解决类似的问题。看下面的例子：
>>> print "小明说：\"我没有少圆明园\""
小明说"我没有少圆明园"
这个例子中，为了打印出那句含有双引号的字符串，也就是双引号是字符串的一部分了，使
用了一个符号：\，在python中，将这个符号叫做转义符。本来双引号表示包括字符串，它不
是字符串一部分，但是如果前面有转义符，那么它就失去了原来的含义，转化为字符串的一
部分，相当于一个特殊字符了
下面用转义符在打印第二句话：
>>> print 'what\'s your name?'
what's your name?
另外，双引号和单引号还可以嵌套，比如下面的句子中，单引号在双引号里面，虽然没有在
单引号前面加转义符，但是它被认为是字符串一部分，而不是包裹字符串的符号
>>> print "what's your name?" #双引号包裹单引号，单引号是字符
what's your name?
>>> print 'what "is your" name' #单引号包裹双引号，双引号是字符
what "is your" name
>>> print '小明说："我没有做作业"'
小明说："我没有做作业"
对字符串的简单操作
>>> "py"+"thon"
'python'
连接字符串1
>>> a = "老齐"
>>> b= "教python"
>>> c = a+b
>>> print c
老齐教python
>>> c
'\xe8\x80\x81\xe9\xbd\x90\xe6\x95\x99python'
用 + 号实现连接，的确比较简单，不过，有时候你会遇到这样的问题：
>>> a = 1989
>>> b = "free"
>>> print b+a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
抱错了，其错误原因已经打印出来了（ 一定要注意看打印出来的信息） ： cannot concatenate
'str' and 'int' objects 。原来 a 对应的对象是一个 int 类型的，不能将它和 str 对象连接
起来。怎么办？
可以用下面三种方法中的任何一种：
>>> print b + `a` #注意，` `是反引号，不是单引号，就是键盘中通常在数字1左边的那个，在英文半角状态下输入的符号
free1989
>>> print b + str(a) #str(a)实现将整数对象转换为字符串对象
free1989
>>> print b + repr(a) #repr(a)与上面的类似
free1989
首先明确，repr()和``是一致的，就不用
区别了。接下来需要区别的就是repr()和str，一个最简单的区别，repr是函数，str是跟int一
样，一种对象类型。
Python转义字符
>>> print "hello.I am qiwsir.\ #这里换行，下一行接续
... My website is 'http://qiwsir.github.io'."
hello.I am qiwsir.My website is 'http://qiwsir.github.io'.
>>> print "you can connect me by qq\\weibo\\gmail" #\\是为了要后面那个\
you can connect me by qq\weibo\gmail
当然也可以直接用单斜杠\ 我试过 都可以运行出来的
连接字符串的方法2
这里暂且了解两个占位符：%d——表示那个位置是整数，%s——表示那个位置应该是字符串
>>> print "one is %d"%1
one is 1
要求打印(print)的内容中，有一个%d占位符，就是说那个位置应该放一个整数。在第二个%
后面，跟着的就是那个位置应该放的东西。这里是一个整数1。
占位符来连接字符串
>>> a = "py"
>>> b = "thon"
>>> print "%s%s"%(a,b) #注
python
注：仔细观察，如果两个占位符，要向这两个位置放东西，代表的东西要写在一个圆括号
内，并且中间用逗号（ 半角） 隔开
字符串复制
>>> a = "My name is LaoQi. I like python and can teach you to learn it."
>>> print a
My name is LaoQi. I like python and can teach you to learn it.
>>> b = a
>>> print b
My name is LaoQi. I like python and can teach you to learn it.
>>> print a
My name is LaoQi. I like python and can teach you to learn it.
复制非常简单，类似与赋值一样。
字符串长度
使用的是一个函数len(object)
>>> a="hello"
>>> len(a)
5
>>> m = len(a) #把结果返回后赋值给一个变量
>>> m
5 >
>> type(m) #这个返回值（ 变量） 是一个整数型
<type 'int'>
字符大小写的转换
S.upper() #S中的字母大写
S.lower() #S中的字母小写
S.capitalize() #首字母大写
S.istitle() #单词首字母是否大写的，且其它为小写
S.isupper() #S中的字母是否全是大写
S.islower() #S中的字母是否全是小写
>>> a = "qiwsir,python"
>>> a.upper() #将小写字母完全变成大写字母
'QIWSIR,PYTHON'
>>> a #原数据对象并没有改变
'qiwsir,python'
>>> b = a.upper()
>>> b
'QIWSIR,PYTHON'
>>> c = b.lower() #将所有的小写字母变成大写字母
>>> c
'qiwsir,python'
>>> a = "Qiwsir,github" #如果这样，也返回False
>>> a.istitle()
False
>>> a = 'Qiwsir,Github' #这样也是True
>>> a.istitle()
True
>>> a = "Qiwsir"
>>> a.isupper()
False
>>> a.upper().isupper()
True
>>> a.islower()
False
>>> a.lower().islower()
True
>>> b = a.title() #这样就把所有单词的第一个字母转化为大写
>>> a = "This is a Book"
>>> a.istitle()
False
>>> b = a.title() #这样就把所有单词的第一个字母转化为大写
>>> b
'This Is A Book'
>>> a.istitle() #判断每个单词的第一个字母是否为大写
False
玩转字符串(3)
在python中按照这样的顺序对字符串进行编号：从左边第一个开始是0号，向下依次按照整数
增加，为1、2...，直到最后一个，在这个过程中，所有字符，包括空格，都进行变编号。
>>> a = "Hello,wor ld"
>>> len(a) #字符串的长度是12,说明公有12个字符，最后一个字符编号是11
12
>>> a[0]
'H'
>>> a[3]
'l'
>>> a[9]
' '
>>> a[11]
'd'
>>> a[5]
','
特别说明，编号是从左边开始，第一个是0。
能不能从右边开始编号呢？可以。这么人见人爱的python难道这点小要求都不满足吗？
>>> a[-1]
'd'
>>> a[11]
'd'
>>> a[-12]
'H'
>>> a[-3]
' '
字符串截取
有了编号，不仅仅能够找出某个字符，还能在字符串中取出一部分来。比如，从“hello,wor
ld”里面取出“llo”。可以这样操作
>>> a[2:5]
'llo'
注意：所截取部分的第一个字符（ l） 对应的编号是(2)，从这里
开始；结束的字符是(o)，对应编号是（ 4） ，但是结束的编号要增加1,不能是4,而是5.这样截
取到的就是上面所要求的了。
试一试，怎么截取到",wor"
也就是说，截取a[n,m]，其中n<m，得到的字符是从a[n]开始到a[m-1]
>>> a[:] #表示截取全部
有几个比较特殊的
>>> a[:] #表示截取全部
'Hello,wor ld'
>>> a[3:] #表示从a[3]开始，一直到字符串的最后
'lo,wor ld'
>>> a[:4] #表示从字符串开头一直到a[4]前结束
'Hell’
去掉字符串两头的空格
方法是：
S.strip() 去掉字符串的左右空格
S.lstrip() 去掉字符串的左边空格
S.rstrip() 去掉字符串的右边空格
>>> b=" hello "
>>> b
' hello '
>>> b.strip()
'hello'
>>> b
' hello '
>>> b.lstrip()
'hello '
>>> b.rstrip()
' hello’
练习
输入用户名，计算机自动向这个用户打招呼。代码如下：
#coding:utf-8
print "please write your name:"
name=raw_input()
print "Hello,%s"%name
这段代码中的raw_input()的含义，就是要用户输入内容，所输入的内容是一个字符串
各种各样的运算符
算术运算符
比较运算符
任何两个同一类型的量的都可以比较，比如两个数字可以比较，两个字符串可以比较。注意，是两个同一类型的。
上面的表格实例中，显示比较的结果就是返回一个true或者false，这是什么意思呢。就是在告
诉你，这个比较如果成立，就是为真，返回True，否则返回False
逻辑运算符 布尔型的变量
所谓布尔类型，就是返回结果为1(True)、0(False)的数据变量。，有三种运算符（and, or, not），可以
实现布尔类型的变量间的运算
and，翻译为“与”运算，但事实上，这种翻译容易引起望文生义的理解。先说一下正确的理
解。A and B，含义是：首先运算A，如果A的值是true，就计算B，并将B的结果返回做为最终结果，如果B是False，那么A and B的最终结果就是False,如果B的结果是True，那么A and B的结果就是True；如果A的值是False ,就不计算B了，直接返回A and B的结果为False.
not，翻译成“非”，窃以为非
语句
一般所有高级语言，都包含如下语句，Python也不例外：
循环语句:容许一些语句反复运行数次。循环可依据一个默认的数目来决定运行这些语句
的次数；或反复运行它们，直至某些条件改变。
条件语句:容许仅当某些条件成立时才运行某个区块。否则，这个区块中的语句会略去，
然后按区块后的语句继续运行。
无条件分支语句容许运行顺序转移到程序的其他部分之中。包括跳跃（ 在很多语言中称
为Goto） 、副程序和Procedure等。
循环、条件分支和无条件分支都是控制流程。
条件语句的基本样式结构：
if 条件1:
执行的内容1
elif 条件2:
执行的内容2
elif 条件3：
执行的内容3
else:
执行的内容4
raw_input()函数了，这个是获得用户在界面上输入的信息，而通过它得到的是字符串类型的数据
#! /usr/bin/env python
#coding:utf-8
print "请输入任意一个整数数字："
number = int(raw_input()) #通过raw_input()输入的数字是字符串
#用int()将该字符串转化为整数
if number == 10:
print "您输入的数字是：%d"%number
print "You are SMART."
elif number > 10:
print "您输入的数字是：%d"%number
print "This number is more than 10."
elif number < 10:
print "您输入的数字是：%d"%number
print "This number is less than 10."
else:
print "Are you a human?"
提醒：每个执行的内容，均以缩进四个空格方式。
>>> a=raw_input()
10
>>> a
'10'
>>> type(a)
<type 'str'>
>>> a=int(a)
>>> a
10
>>> type(a)
<type 'int'>
刚刚得到的那个a就是str类型，如果用int()转换一下，就变成int类型了。
看来int()可以将字str类型的数字转换为int类型，类似，是不是有这样的结论呢：str()可以将int类型的数字转化为str类型. 可以的√
我的QQ公布一下：
26066913，或者登录我的微博，通过微博跟我联系，当然还可以发邮件啦
>>> a="http://qiwsir.github.io"
>>> a
'http://qiwsir.github.io'
>>> print a
http://qiwsir.github.io
当给一个变量a赋值于一个字符串之后，输入变量名称，就能够打印出字符串，和print a具有同样的效果
#布尔型,用bool()表示，就类似int(),str()，是一个内置函数
如果对象是空，返回False，如果不是，则返回True；如果对象是False，返回False。
两种python的数据类型：int和str。
这个世界是由数据组成的，数据可能是数字（ 注意，别搞混了，数字和数据是有区别的） ，也可能是文字、或者是声音、视频等。
LIST在python中具有非常强大的功能
在python中，用方括号表示一个list，[ ]在方括号里面，可以是int，也可以是str类型的数据，甚至也能够是True/False这种布尔值
>>> a=[] #定义了一个变量a，它是list类型，并且是空的。
>>> type(a)
<type 'list'> #用内置函数type()查看变量a的类型，为list
>>> bool(a) #用内置函数bool()看看list类型的变量a的布尔值，因为是空的，所以为False
False
>>> print a #打印list类型的变量a
[]
>>> a=['2',3,'qiwsir.github.io']
>>> a
['2', 3, 'qiwsir.github.io']
>>> type(a)
<type 'list'>
>>> bool(a)
True
>>> print a
['2', 3, 'qiwsir.github.io']
就指明了list的一大特点：可以无限大，就是说list里面所能容纳的元素数量无限
>>> a
['2', 3, 'qiwsir.github.io']
>>> a[0] #索引序号也是从0开始
'2'
>>> a[1]
3 >
>> [2]
[2]
>>> a[:2] #跟str中的类似，切片的范围是：包含开始位置，到结束位置之前
['2', 3] #不包含结束位置
>>> a[1:]
[3, 'qiwsir.github.io']
>>> a[-1] #负数编号从右边开始
'qiwsir.github.io'
>>> a[-2]
3 >
>> a[:]
['2', 3, 'qiwsir.github.io']
追加元素
>>> a = ["good","python","I"]
>>> a
['good', 'python', 'I']
>>> a.append("like") #向list中添加str类型"like"
>>> a
['good', 'python', 'I', 'like']
>>> a.append(100) #向list中添加int类型100
>>> a
['good', 'python', 'I', 'like', 100]
list.append(x)
Add an item to the end of the list; equivalent to a[len(a):] = [x].
应该注意到，还有后面半句： equivalent
to a[len(a):] = [x]，意思是说list.append(x)等效于：a[len(a):]=[x]。这也相当于告诉我们了另外一种追加元素的方法，并且两种方法等效
>>> a
['good', 'python', 'I', 'like', 100]
>>> a[len(a):]=[3] #len(a),即得到list的长度，这个长度是指list中的元素个数。
>>> a
['good', 'python', 'I', 'like', 100, 3]
>>> len(a)
6 >
>> a[6:]=['xxoo']
>>> a
['good', 'python', 'I', 'like', 100, 3, 'xxoo']
顺便说一下len()，这个是用来获取list,str等类型的数据长度的
>>> name = 'yeashape'
>>> len(name) #str的长度，是字符的个数
8 >
>> a=[1,2,'a','b'] #list的长度，是元素的个数
>>> len(a)
4 >
>> b=['yeashape']
>>> len(b)
1
len(x)，对于list一样适用
得到的是list中元素个数
返回值是int类型
list.extend(L)
Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L.
向所有正在学习本内容的朋友提供一个成为优秀程序员的必备：看官方文档，是必须的。
官方文档的这句话翻译过来：
通过将所有元素追加到已知list来扩充它，相当于a[len(a)]= L
>>> la
[1, 2, 3]
>>> lb
['qiwsir', 'python']
>>> la.extend(lb)
>>> la
[1, 2, 3, 'qiwsir', 'python']
>>> lb
['qiwsir', 'python']
上面的例子，显示了如何将两个list，一个是la，另外一个lb，将lb追加到la的后面，也就是把lb中的所有元素加入到la中，即让la扩容。学程序一定要有好奇心，我在交互环境中，经常实验一下自己的想法，
>>> la = [1,2,3]
>>> b = "abc"
>>> la.extend(b)
>>> la
[1, 2, 3, 'a', 'b', 'c']
>>> c = 5
>>> la.extend(c)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable 不可迭代
如果extend(str)的时候，str被以字符为单位拆开，然后追加到la里面。如果extend的对象是数值型，则报错。所以，extend的对象是一个list，如果是str，则python会先把它按照字符为单位转化为list再追加到已知list。
list.extend(L) 等效于 list[len(list):] = L，L是待并入的list
联想到到上一讲中的一个list函数list.append(),这里的extend函数也是将另外的元素（只不过这个元素是列表） 增加到一个已知列表中，那么两者有什么不一样呢？看下面例子：
>>> lst = [1,2,3]
>>> lst.append(["qiwsir","github"])
>>> lst
[1, 2, 3, ['qiwsir', 'github']] #append的结果
>>> len(lst)
4 >
>> lst2 = [1,2,3]
>>> lst2.extend(["qiwsir","github"])
>>> lst2
[1, 2, 3, 'qiwsir', 'github'] #extend的结果
>>> len(lst2)
5
append是整建制地追加，extend是个体化扩编。
字符命名不能以数字开头
在list前面加元素也是可以的
list.count(x)
Return the number of times x appears in the list.
>>> la = [1,2,1,1,3]
>>> la.count(1)
3 >
>> la.append('a')
>>> la.append('a')
>>> la
[1, 2, 1, 1, 3, 'a', 'a']
>>> la.count('a')
2 >
>> la.count(2)
1 >
>> la.count(5) #NOTE:la中没有5,但是如果用这种方法找，不报错，返回的是数字0
0
>>> la
[1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']
>>> la[2]
3
如果考虑反过来的情况，能不能通过某个元素，找到它在list中的编号呢？
看官的需要就是python的方向，你想到，python就做到。
>>> la
[1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python']
>>> la.index(3)
2 >
>> la.index('a')
3
list.index(x)，x是list中的一个元素，这样就能够检索到该元素在list中的位置了。这才是真正
的索引，注意那个英文单词index。
依然是上一条官方解释：
list.index(x)
Return the index in the list of the first item whose value is x. It is an error if there is no such item
与list.append(x)类似，list.insert(i,x)也是对list元素的增加。只不过是可以在任何位置增加一个
元素。
我特别引导列为看官要通过官方文档来理解：
list.insert(i, x)
Insert an item at a given position. The first argument is the index of the element
before which to insert, so a.insert(0, x) inserts at the front of the list, and
a.insert(len(a), x) is equivalent to a.append(x)
>>> all_users
['qiwsir', 'github', 'io']
>>> all_users.insert("python") #list.insert(i,x),要求有两个参数，少了就报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: insert() takes exactly 2 arguments (1 given)
>>> all_users.insert(0,"python")
>>> all_users
['python', 'qiwsir', 'github', 'io']
>>> all_users.insert(1,"http://")
>>> all_users
['python', 'http://', 'qiwsir', 'github', 'io']
小结：
list.insert(i,x),将新的元素x 插入到原list中的list[i]前面
如果i==len(list)，意思是在后面追加，就等同于list.append(x)
删除list中的元素
list中的元素，不仅能增加，还能被删除。删除list元素的方法有两个，它们分别是：
list.remove(x)
Remove the first item from the list whose value is x. It is an error if there is no such item.
注意两点：
如果正确删除，不会有任何反馈。没有消息就是好消息。
如果所删除的内容不在list中，就报错。注意阅读报错信息：x not in list
>>> all_users
['python', 'qiwsir', 'github', 'io', 'algorithm']
>>> "python" in all_users
True
#这里用in来判断一个元素是否在list中，在则返回True，否回False#
>>> if "python" in all_users:
... all_users.remove("python")
... print all_users
... else:
... print "'python' is not in all_users"
...
['qiwsir', 'github', 'io', 'algorithm'] #删除了"python"元素
>>> if "python" in all_users:
... all_users.remove("python")
... print all_users
... else:
... print "'python' is not in all_users"
...
'python' is not in all_users #因为已经删除了，所以就没有了
>>> all_users
['qiwsir', 'github', 'io', 'algorithm']
>>> all_users.pop() #list.pop([i]),圆括号里面是[i]，表示这个序号是可选的
'algorithm' #如果不写，就如同这个操作，默认删除最后一个，并且将该结果返回
>>> all_users
['qiwsir', 'github', 'io']
>>> all_users.pop(1) #指定删除编号为1的元素"github"
'github'
对list的操作
range(start,stop)生成数字list
range(start, stop[, step])是一个内置函数。
从这段话，我们可以得出关于range()函数的以下几点：
这个函数可以创建一个数字元素组成的列表。
这个函数最常用于for循环（关于for循环，马上就要涉及到了）
函数的参数必须是整数，默认从0开始。返回值是类似[start, start + step, start + 2*step,
...]的列表。
step默认值是1。如果不写，就是按照此值
在实验开始之前，再解释range(start,stop[,step])的含义：
start：开始数值，默认为0,也就是如果不写这项，就是认为start=0
stop：结束的数值，必须要写的。
step：变化的步长，默认是1,也就是不写，就是认为步长为1。坚决不能为0
>>> range(9) #stop=9，别的都没有写，含义就是range(0,9,1)
[0, 1, 2, 3, 4, 5, 6, 7, 8] #从0开始，步长为1,增加，直到小于9的那个数
>>> range(0,9,2) #step=2,每个元素等于start+i*step，
[0, 2, 4, 6, 8]
start=0,step=2,stop=9.list中的第一个值是start=0,第二个值是start+1step=2（注意，这里
是1，不是2，不要忘记，前面已经讲过，不论是list还是str，对元素进行编号的时候，都
是从0开始的） ，第n个值就是start+(n-1)step。直到小于stop前的那个值。
["I","am","a","pythoner","I","am","learning","it","with","qiwsir"],要得到这个list的所有序号组成的
list，但是不能一个一个用手指头来数。怎么办？
请沉思两分钟之后，自己实验一下，然后看下面。
>>> pythoner
['I', 'am', 'a', 'pythoner', 'I', 'am', 'learning', 'it', 'with', 'qiwsir']
>>> py_index = range(len(pythoner)) #以len(pythoner)为stop的值
>>> py_index
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
再用手指头指着pythoner里面的元素，数一数，是不是跟结果一样。
有关算法排序的网址python https://github.com/qiwsir/algorithm/blob/master/README.md
假设有一个list，如何知道它所拥有的内置函数呢？请用help()，帮助我吧。
>>> help(list)
list和str比较
1.
>>> welcome_str = "Welcome you"
>>> welcome_str[0]
'W'
>>> welcome_str[1]
'e'
>>> welcome_str[len(welcome_str)-1]
'u'
>>> welcome_str[:4]
'Welc'
>>> a = "python"
>>> a*3
'pythonpythonpython'
>>> git_list = ["qiwsir","github","io"]
>>> git_list[0]
'qiwsir'
>>> git_list[len(git_list)-1]
'io'
>>> git_list[0:2]
['qiwsir', 'github']
>>> b = ['qiwsir']
>>> b*7
['qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir']
2.
>>> first = "hello,world"
>>> welcome_str
'Welcome you'
>>> first+","+welcome_str #用+号连接str
'hello,world,Welcome you'
>>> welcome_str #原来的str没有受到影响，即上面的+号连接后从新生成了一个字符串
'Welcome you'
>>> first
'hello,world'
>>> language = ['python']
>>> git_list
['qiwsir', 'github', 'io']
>>> language + git_list #用+号连接list，得到一个新的list
['python', 'qiwsir', 'github', 'io']
>>> git_list
['qiwsir', 'github', 'io']
>>> language
['python']
>>> len(welcome_str) #得到字符数
11
>>> len(git_list) #得到元素数
3
区别
list和str的最大区别是：list是可以改变的，str不可变。
>>> git_list.append("python")
>>> git_list
['qiwsir', 'github', 'io', 'python']
>>> git_list[1]
'github'
>>> git_list[1] = 'github.com'
>>> git_list
['qiwsir', 'github.com', 'io', 'python']
>>> git_list.insert(1,"algorithm")
>>> git_list
['qiwsir', 'algorithm', 'github.com', 'io', 'python']
>>> git_list.pop()
'python'
>>> del git_list[1]
>>> git_list
['qiwsir', 'github.com', 'io']
其实，在这种做法中，相当于从新生成了一个str。
多维list
在str中，里面的每个元素只能是字符，在list中，元素可以是任何类型的数据
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix[0][1]
2 >
>> mult = [[1,2,3],['a','b','c'],'d','e']
>>> mult
[[1, 2, 3], ['a', 'b', 'c'], 'd', 'e']
>>> mult[1][1]
'b'
>>> mult[2]
'd’
list和str转化
str.split()
这个内置函数实现的是将str转化为list。其中str=""是分隔符。
>>>help(str.split)
>>> line = "Hello.I am qiwsir.Welcome you."
>>> line.split(".") #以英文的句点为分隔符，得到list
['Hello', 'I am qiwsir', 'Welcome you', '']
>>> line.split(".",1) #这个1,就是表达了上文中的：If maxsplit is given, at most maxsplit splits are done.
['Hello', 'I am qiwsir.Welcome you.']
>>> name = "Albert Ainstain" #也有可能用空格来做为分隔符
>>> name.split(" ")
['Albert', 'Ainstain']
>>> s = "I am, writing\npython\tbook on line" #这个字符串中有空格，逗号，换行\n，tab缩进\t 符号
>>> print s #输出之后的样式
I am, writing
python book on line
>>> s.split() #用split(),但是括号中不输入任何参数
['I', 'am,', 'writing', 'python', 'book', 'on', 'line']
"[sep]".join(list)
join可以说是split的逆运算，举例：
>>> name
['Albert', 'Ainstain']
>>> "".join(name) #将list中的元素连接起来，但是没有连接符，表示一个一个紧邻着
'AlbertAinstain'
>>> ".".join(name) #以英文的句点做为连接分隔符
'Albert.Ainstain'
>>> " ".join(name) #以空格做为连接的分隔符
'Albert Ainstain'
简单的for循环例子
>>> hello = "world"
>>> for i in hello:
... print i
...
w o r l d
在打印的后面加一个逗号（ 英文）
>>> for i in hello:
... print i,
...
w o r l d
>>> for i in hello:
... print i+",", #为了美观，可以在每个字符后面加一个逗号分割
...
w, o, r, l, d,
>>>
索引编号（ 偏移量） 做为下表，得到某个字符。所以，还可以通过下面的
循环方式实现上面代码中同样功能：
零基础学Python
画圈还不简单吗 94
>>> for i in range(len(hello)):
... print hello[i]
...
w o r l d
其工作方式是：
1. len(hello)得到hello引用的字符串的长度，为5
2. range(len(hello),就是range(5),也就是[0, 1, 2, 3, 4],对应这"world"每个字母的编号，即偏
移量。
3. for i in range(len(hello)),就相当于for i in [0,1,2,3,4],让i依次等于list中的各个值。当i=0
时，打印hello[0]，也就是第一个字符。然后顺序循环下去，直到最后一个i=4为
显示了对字str的字符依次获取，也涉及了list，感觉不过瘾呀。那好，看
下面对list的循环：
>>> ls_line
['Hello', 'I am qiwsir', 'Welcome you', '']
>>> for word in ls_line:
... print word
...
Hello
I am qiwsir
Welcome you
>>> for i in range(len(ls_line)):
... print ls_line[i]
...
Hello
I am qiwsir
Welcome you
for语句的基本工作流程，如果写一个一般化的公式，可以这么表示：
for 循环规则：
操作语句
例：找出100以内的能够被3整除的正整数。
分析：这个问题有两个限制条件，第一是100以内的正整数，根据前面所学，可以用
range(1,100)来实现；第二个是要解决被3整除的问题，假设某个正整数n，这个数如果能够被3整除，也就是n%3(%是取余数)为0.那么如何得到n呢，就是要用for循环
#! /usr/bin/env python
#coding:utf-8
aliquot = []
for n in range(1,100):
if n%3 == 0:
aliquot.append(n)
print aliquot
先看下面的例子，这个例子是想得到1到9的每个整数的平方，并且将结果放在list中打印出来
>>> power2 = []
>>> for i in range(1,10):
... power2.append(i*i)
...
>>> power2
[1, 4, 9, 16, 25, 36, 49, 64, 81]
python有一个非常有意思的功能，就是list解析，就是这样的：
>>> squares = [x**2 for x in range(1,10)]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81]
aliquot = []
for n in range(1,100):
if n%3 == 0:
aliquot.append(n)
print aliquot
好了。现在用list解析重写，会是这样的：
>>> aliquot = [n for n in range(1,100) if n%3==0]
>>> aliquot
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69,
>>> mybag = [' glass',' apple','green leaf '] #有的前面有空格，有的后面有空格
>>> [one.strip() for one in mybag] #去掉元素前后的空格
['glass', 'apple', 'green leaf']
Enumerate
这是一个有意思的内置函数，本来我们可以通过for i in range(len(list))的方式得到一个list的每
个元素编号，然后在用list[i]的方式得到该元素。如果要同时得到元素编号和元素怎么办？就
是这样了:
>>> for i in range(len(week)):
... print week[i]+' is '+str(i) #注意，i是int类型，如果和前面的用+连接，必须是str类型
...
monday is 0
sunday is 1
friday is 2
>>> for (i,day) in enumerate(week):
... print day+' is '+str(i)
...
monday is 0
sunday is 1
friday is 2
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
括号可要可不要
看官也可以用小话题大函数中的lambda函数来写上面的代码：
>>> seq = ["qiwsir","qiwsir.github.io","python"]
>>> foo = lambda i,ele:"%d:%s"%(i,ele) #lambda函数，给代码带来了简介
>>> [foo(i,ele) for i,ele in enumerate(seq)]
['0:qiwsir', '1:qiwsir.github.io', '2:python']
这个结果有时候能运新出来 有时候出不来 大多数情况都出不来
在python中，也有一种数据与此相近，不仅相近，这种数据的名称就叫做dictionary，翻译过来是字典，类似于前面的int/str/list，这种类型数据名称是:dict
>>>help(str)
将得到所有的有关内容。
现在换一个，使用dir，也能得到相同的结果。只是简单一些罢了。请在交互模式下：
>>> dir(dict)
['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__
如果要想深入了解，可以这样：
>>> help(dict.values)
python中的dict具有如下特点：
dict是可变的
dict可以存储任意数量的Python对象
dict可以存储任何python数据类型
dict以：key:value，即“键：值”对的形式存储数据，每个键是唯一的。
dict也被称为关联数组或哈希表。
创建一个空的dict，这个空dict，可以在以后向里面加东西用。
>>> mydict = {}
>>> mydict
{}
>>> person = {"name":"qiwsir","site":"qiwsir.github.io","language":"python"}
>>> person
{'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'}
"name":"qiwsir"就是一个键值对，前面的name叫做键（ key） ，后面的qiwsir是前面的键所对应的值(value)。在一个dict中，键是唯一的，不能重复；值则是对应于键，值可以重复。键值之间用(:)英文的分号，每一对键值之间用英文的逗号(,)隔开
如下，演示了从一个空的dict开始增加内容的过程
>>> mydict = {}
>>> mydict
{}
>>> mydict["site"] = "qiwsir.github.io"
>>> mydict[1] = 80
>>> mydict[2] = "python"
>>> mydict["name"] = ["zhangsan","lisi","wangwu"]
>>> mydict
{1: 80, 2: 'python', 'site': 'qiwsir.github.io', 'name': ['zhangsan', 'lisi', 'wangwu']
>>> mydict[1] = 90 #如果这样，则是修改这个键的值
>>> mydict
{1: 90, 2: 'python', 'site': 'qiwsir.github.io', 'name': ['zhangsan', 'lisi', 'wangwu']}
方法2:
>>> name = (["first","Google"],["second","Yahoo"]) #这是另外一种数据类型，称之为元组，后面会讲到
>>> website = dict(name)
>>> website
{'second': 'Yahoo', 'first': 'Google'}
方法3:
这个方法，跟上面的不同在于使用fromkeys
>>> website = {}.fromkeys(("third","forth"),"facebook")
>>> website
{'forth': 'facebook', 'third': 'facebook'}
>>> person
{'name2': 'qiwsir', 'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'}
>>> person['name']
'qiwsir'
>>> person['language']
'python'
>>> site = person['site']
>>> print site
qiwsir.github.io
dict是不是也可以用for语句来循环访问呢？当然可以，来看例子：
>>> person
{'name2': 'qiwsir', 'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'}
>>> for key in person:
... print person[key]
...
qiwsir
qiwsir
python
qiwsir.github.io
计算机科学中，关联数组（ 英语：Associative Array） ，又称映射（ Map） 、字典
（ Dictionary） 是一个抽象的数据结构，它包含着类似于（ 键，值） 的有序对。一个关联数组中的有序对可以重复（ 如C++中的multimap） 也可以不重复（ 如C++中的map）
这种数据结构包含以下几种常见的操作：
1.向关联数组添加配对 2.从关联数组内删除配对 3.修改关联数组内的配对 4.根据已
知的键寻找配对
嵌套在list中也存在，就是元素是list，在dict中，也有类似的样式：
>>> a_list = [[1,2,3],[4,5],[6,7]]
>>> a_list[1][1]
5 >
>> a_dict = {1:{"name":"qiwsir"},2:"python","email":"qiwsir@gmail.com"}
>>> a_dict
{1: {'name': 'qiwsir'}, 2: 'python', 'email': 'qiwsir@gmail.com'}
>>> a_dict[1]['name'] #一个嵌套的dict访问其值的方法：一层一层地写出键
'qiwsir
获取键、值
在上一讲中，已经知道可以通过dict的键得到其值。例上面的例子。
还有别的方法得到键值吗
>>> website = {1:"google","second":"baidu",3:"facebook","twitter":4}
>>>#用d.keys()的方法得到dict的所有键，结果是list
>>> website.keys()
[1, 'second', 3, 'twitter']
>>>#用d.values()的方法得到dict的所有值，如果里面没有嵌套别的dict，结果是list
>>> website.values()
['google', 'baidu', 'facebook', 4]
>>>#用items()的方法得到了一组一组的键值对，
>>>#结果是list，只不过list里面的元素是元组
>>> website.items()
[(1, 'google'), ('second', 'baidu'), (3, 'facebook'), ('twitter', 4)]
可以用for语句循环得到相应内容
>>> for key in website.keys():
... print key,type(key)
...
1 <type 'int'>
second <type 'str'>
3 <type 'int'>
twitter <type 'str'>
>>>#下面的方法和上面的方法是一样的
>>> for key in website:
... print key,type(key)
...
1 <type 'int'>
second <type 'str'>
3 <type 'int'>
twitter <type 'str'>
以下两种方法等效：
>>> for value in website.values():
... print value
...
baidu
4 >
>> for key in website:
... print website[key]
...
baidu
4
下面的方法又是等效的
>>> for k,v in website.items():
... print str(k)+":"+str(v)
...
1:google
second:baidu
3:facebook
twitter:4
>>> for k in website:
... print str(k)+":"+str(website[k])
...
1:google
second:baidu
3:facebook
twitter:4
介绍一种新的数据类型:集合(set).
tuple算是list和str的杂合(杂交的都有自己的优势,上一节的末后已经显示了),那么set则可以堪称是list和dict的杂合.
set拥有类似dict的特点:可以用{}花括号来定义；其中的元素没有序列,也就是是非序列类型的数据;而且,set中的元素不可重复,这就类似dict的键.
set也有继承了一点list的特点:如可以原处修改，事实上是一种类别的set可以原处修改,另外一种不可以)
>>> s1 = set("qiwsir") #把str中的字符拆解开,形成set.特别注意观察:qiwsir中有两个i
>>> s1 #但是在s1中,只有一个i,也就是不能重复
set(['q', 'i', 's', 'r', 'w'])
>>> s2 = set([123,"google","face","book","facebook","book"]) #通过list创建set.不能有重复,元素可以是int/
>>> s2
set(['facebook', 123, 'google', 'book', 'face']) #元素顺序排列不是按照指定顺序
>>> s3 = {"facebook",123} #通过{}直接创建
>>> s3
set([123, 'facebook'])
>>> s3 = {"facebook",[1,2,'a'],{"name":"python","lang":"english"},123}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> s3 = {"facebook",[1,2],123}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
通过{}无法创建含有list/dict元素的set.
>>> a_set = {} #我想当然地认为这样也可以建立一个set
>>> a_set.add("qiwsir") #报错.看看错误信息,居然告诉我dict没有add.我分明建立的是set呀.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
特别说明一下,{}这个东西,在dict和set中都用.但是,如上面的方法建立的是dict,不是set.这是python规定的.要建立set,只能用前面介绍的方法了.
>>> a_set = {'a','i'} #这回就是set了吧
>>> a_set.add("qiwsir") #增加一个元素
>>> a_set #原处修改,即原来的a_set引用对象已经改变
set(['i', 'a', 'qiwsir'])
>>> b_set = set("python")
>>> type(b_set)
<type 'set'>
>>> b_set
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> b_set.add("qiwsir")
>>> b_set
set(['h', 'o', 'n', 'p', 't', 'qiwsir', 'y'])
>>> b_set.add([1,2,3]) #这样做是不行滴,跟前面一样,报错.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> b_set.add('[1,2,3]') #可以这样!
>>> b_set
set(['[1,2,3]', 'h', 'o', 'n', 'p', 't', 'qiwsir', 'y'])
除了上面的增加元素方法之外,还能够从另外一个set中合并过来元素,方法是set.update(s2)
>>> help(set.update)
update(...)
Update a set with the union of itself and others.
>>> s1
set(['a', 'b'])
>>> s2
set(['github', 'qiwsir'])
>>> s1.update(s2) #把s2的元素并入到s1中.
>>> s1 #s1的引用对象修改
set(['a', 'qiwsir', 'b', 'github'])
>>> s2 #s2的未变
set(['github', 'qiwsir'])
pop(...)
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
>>> b_set
set(['[1,2,3]', 'h', 'o', 'n', 'p', 't', 'qiwsir', 'y'])
>>> b_set.pop() #从set中任意选一个删除,并返回该值
'[1,2,3]'
>>> b_set.pop()
'h'
>>> b_set.pop()
'o'
>>> b_set
set(['n', 'p', 't', 'qiwsir', 'y'])
>>> b_set.pop("n") #如果要指定删除某个元素,报错了.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)
set.pop()是从set中任意选一个元素,删除并将这个值返回.但是,不能指定删除某个元素.报错信息中就告诉我们了,pop()不能有参数.此外,如果set是空的了,也报错.
要删除指定的元素,怎么办?
set.remove(obj)中的obj,必须是set中的元素,否则就报错.试一试:
>>> a_set
set(['i', 'a', 'qiwsir'])
>>> a_set.remove("i")
>>> a_set
set(['a', 'qiwsir'])
>>> a_set.remove("w")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'w'
跟remove(obj)类似的还有一个discard(obj):
>>> help(set.discard)
discard(...)
Remove an element from a set if it is a member.
If the element is not a member, do nothing.与help(set.remove)的信息对比,看看有什么不同.discard(obj)中的obj如果是set中的元素,就删除,如果不是,就什么也不做,do nothing.
>>> a_set.discard('a')
>>> a_set
set(['qiwsir'])
>>> a_set.discard('b')
>>>
一个绝杀,就是set.clear(),它的功能是:Remove all elements from this set.(看官自己在交互模式下help(set.clear))
>>> a_set
set(['qiwsir'])
>>> a_set.clear()
>>> a_set
set([])
>>> bool(a_set) #空了,bool一下返回False.
False
集合的关系：冻结的集合
>>> f_set = frozenset("qiwsir") #看这个名字就知道了frozen，冻结的set
>>> f_set
frozenset(['q', 'i', 's', 'r', 'w'])
>>> f_set.add("python") #报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> a_set = set("github") #对比看一看，这是一个可以原处修改的set
>>> a_set
set(['b', 'g', 'i', 'h', 'u', 't'])
>>> a_set.add("python")
>>> a_set
set(['b', 'g', 'i', 'h', 'python', 'u', 't'])
>>> aset
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> "a" in aset
False
>>> "h" in aset
True
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a == b
False
>>> a != b
True
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> c
set(['q', 'i'])
>>> c<a #c是a的子集
True
>>> c.issubset(a) #或者用这种方法，判断c是否是a的子集
True
>>> a.issuperset(c) #判断a是否是c的超集
True
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a<b #a不是b的子集
False
>>> a.issubset(b) #或者这样做
False
A、B的并集，即A、B所有元素
a.union(b)
set(['a', 'i', 'l', 'o', 'q', 's', 'r', 'w'])
A、B的交集，即A、B所公有的元素
a.intersection(b)
set(['q', 'i'])
>>> a and b
set(['a', 'q', 'i', 'l', 'o'])
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a - b
set(['s', 'r', 'w'])
>>> a.difference(b)
set(['s', 'r', 'w'])
-A、B的对称差集
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a.symmetric_difference(b)
set(['a', 'l', 'o', 's', 'r', 'w'])
类型总结：
不论任何类型的数据，只要动用dir(object)或者help(obj)就能够在交互模式下查看到有关的函数，也就是这样能够查看相关帮助文档了
help(dict.pop)的方式获得
有没有发现这个："\_doc__"。这是什么，它是一个文件，里面记录了
对当前所查看的对象的详细解释。可以在交互模式下这样查看：
>>> dict.__doc__
查看某个数据类型含义的方法，就是通过obj.__doc__文件来看。
变量无类型，对象有类型
这里特别强调，只要用一个变量，就要给这个变量赋值。
所以，像这样是不行的。
>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
变量就是存在系统中的一个东西，这个东西有一种能力，能够用一根线与某对象连接，它能够钓鱼。
在机器的内存中，系统分配一个空间，这里面就放着所谓的对象，有时
候放数字，有时候放字符串。如果放数字，就是int类型，如果放字符串，就是str类型。
就是前面说的变量用自己所拥有的能力，把对象和自己连接起来（指针连接
对象空间） ，这就是引用。引用完成，就实现了赋值。
所以，严格地将，只有放在内存空间中的对象（也就是数据） 才有类型，而变量是没有类型的
变量就好比钓鱼的人，湖水里就好像内存，里面有好多鱼，有各种各样的鱼，它们就是对象。钓鱼的人（变量） 的任务就是用某种方式（鱼儿引诱） 把自己和鱼通过鱼线连接起来。那么，鱼是有类型的，有鲢鱼、鲫鱼、带鱼（带鱼也跑到湖水了了，难道是淡水带鱼？呵呵，就这么扯淡吧，别较真） ，钓鱼的人（变量） 没有这种类型，他钓到不同类型的鱼。
>>> x = 4
>>> x = 5
>>> x
5
变量x先指向了对象4，然后指向对象5，当后者放生的时候，自动跟第一个对象4解除关系。再看x，引用的对象就是5了。那么4呢？一旦没有变量引用它了，它就变成了孤魂野鬼。
is和==的效果
>>> l1 = [1,2,3]
>>> l2 = l1
>>> l1[0] = 99 #把对象变为[99,2,3]
>>> l1 #变了
[99, 2, 3]
>>> l2 #真的变了吔
[99, 2, 3]
>>> l1
[1, 2, 3]
>>> l2
[1, 2, 3]
>>> l1 == l2 #两个相等，是指内容一样
True
>>> l1 is l2 #is 是比较两个引用对象在内存中的地址是不是一样
False #前面的检验已经说明，这是两个东东
>>> l3 = l1 #顺便看看如果这样，l3和l1应用同一个对象
>>> l3
[1, 2, 3]
>>> l3 == l1
True
>>> l3 is l1 #is的结果是True
True
某些对象，有copy函数，通过这个函数得到的对象，是一个新的还是引用到同一个对象呢？
看官也可以做一下类似上面的实验
>>> l1
[1, 2, 3]
>>> l2 = l1[:]
>>> l2
[1, 2, 3]
>>> l1[0] = 22
>>> l1
[22, 2, 3]
>>> l2
[1, 2, 3]
>>> adict = {"name":"qiwsir","web":"qiwsir.github.io"}
>>> bdict = adict.copy()
>>> bdict
{'web': 'qiwsir.github.io', 'name': 'qiwsir'}
>>> adict["email"] = "qiwsir@gmail.com"
>>> adict
{'web': 'qiwsir.github.io', 'name': 'qiwsir', 'email': 'qiwsir@gmail.com'}
>>> bdict
{'web': 'qiwsir.github.io', 'name': 'qiwsir'}
不过，看官还有小心有点，python不总按照前面说的方式出牌，比如小数字的时候
>>> x = 2
>>> y = 2
>>> x is y
True
>>> x = 200000
>>> y = 200000
>>> x is y #什么道理呀，小数字的时候，就用缓存中的.
False
>>> x = 'hello'
>>> y = 'hello'
>>> x is y
True
>>> x = "what is you name?"
>>> y = "what is you name?"
>>> x is y #不光小的数字，短的字符串也是
False
感觉要被玩坏了
变量名称的问
题，本温故而知新的原则，这里要复习：
名称格式：（下划线或者字母） +（任意数目的字母，数字或下划线）
注意：
1. 区分大小写
2. 禁止使用保留字
3. 遵守通常习惯
4. 以单一下划线开头的变量名（_X)不会被from module import *语句导入的。
5. 前后有下划线的变量名（X)是系统定义的变量名，对解释器有特殊意义。
6. 以两个下划线开头，但结尾没有两个下划线的变量名（__X)是类本地（压缩） 变量。
7. 通过交互模式运行时，只有单个下划线变量(_)会保存最后的表达式结果
在交互模式的实验室中，用保留字做变量，就报错了。当然，这时候就要换名字了。
取名字，讲究不少。不论如何，要记住一个标准：明确
赋值
语句格式：变量名称 = 对象
还有一种赋值方式，叫做隐式赋值，通过import、from、del、class、for、函数参数。等模块导入，函数和类的定义，for循环变量以及函数参数都是隐式赋值运算。这方面的东西后面会徐徐道来。
name, website = "qiwsir","qiwsir.github.io" #多个变量，按照顺序依次赋值
>>> name
'qiwsir'
>>> website
'qiwsir.github.io'
>>> name, website = "qiwsir" #有几个变量，就对应几个对象，不能少，也不能多
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack
如果这样赋值，也得两边数目一致：
>>> one,two,three,four = "good"
>>> one
'g'
>>> two
'o'
>>> three
'o'
>>> four
'd’
这样也可以：
>>> [name,site] = ["qiwsir","qiwsir.github.io"]
>>> name
'qiwsir'
>>> site
'qiwsir.github.io'
>>> name,site = ("qiwsir","qiwsir.github.io")
>>> name
'qiwsir'
>>> site
'qiwsir.github.io'
赋值的样式不少，核心就是将变量和某对象对应起来
>>> site = "qiwsir.github.io"
>>> name, main = site.split(".")[0], site.split(".")[1] #还记得str.split(<sep>)这个东东吗？忘记了，googl
>>> name
'qiwsir'
>>> main
'github'
增强赋值
>>> number
[1, 2, 3, 4, 5]
>>> number2 = []
>>> for i in number:
... i = i+2
... number2.append(i)
...
>>> number2
[3, 4, 5, 6, 7]
如果用上面的增强赋值，i = i+2可以写成 i +=2
因为i +=2，比i = i+2计算更快，后者右边还要拷贝一个i。
？？？？None,none
坑爹的字符编码
字符编码（英语：Character encoding） ASCII美国信息交换标准代码
encode()和decode()两个内置函数起吧
python2默认的编码是ascii，通过encode可以将对象的编码转换为指定编码格式，而decode是这个过程的逆过程。通过decode函数，将字节串转变为字符串，并且这个字符串是按照unicode编码的。
#Python2.x的中文显示方法
python在安装时，默认的编码是ascii，当程序中出现非ascii编码时，python的处理常常会报这样的错
UnicodeDecodeError: 'ascii' codec can't decode byte 0x?? in position 1: ordinal not in range(128)，
python没办法处理非ascii编码的，此时需要自己设置将python的默认编码，一般设置为utf8的编码格式。
查询系统默认编码可以在解释器中输入以下命令： Python代码
>>>sys.getdefaultencoding()
设置默认编码时使用： Python代码
>>>sys.setdefaultencoding('utf8')
可能会报
AttributeError: 'module' object has no attribute 'setdefaultencoding'
的错误，执行reload(sys)，在执行以上命令就可以顺利通过。
的错误，执行reload(sys)，在执行以上命令就可以顺利通过。
此时在执行sys.getdefaultencoding()就会发现编码已经被设置为utf8的了，但是在解释器里修改的编码只能保证当次有效，在重启解释器后，会发现，编码又被重置为默认的ascii了，那么有没有办法一次性修改程序或系统的默认编码呢。
###有2种方法设置python的默认编码：
一个解决的方案在程序中加入以下代码： Python代码
import sys
reload(sys)
sys.setdefaultencoding('utf8')
另一个方案是在/usr/local/lib/python.27/site-packages或者/usr/lib/python2.7下新建一个sitecustomize.py，内容为： Python代码， 两个路径的原因是因为系统不同的原因，debian和ubuntu存放的目录是后者，其他没有测试。
# encoding=utf8
import sys
reload(sys)
sys.setdefaultencoding('utf8')
还是没有结果
要实现随机选择一个数字，可以使用python中的一个随机函数：random。
>>> import random #这个是必须的，因为不是内置函数
>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', 'Wi
>>> help(random.randint)
Help on method randint in module random:
randint(self, a, b) method of random.Random instance
Return random integer in range [a, b], including both end points.
随机整数：
>>> import random
>>> random.randint(0,99)
21
随机选取0到100间的偶数：
>>> import random
>>> random.randrange(0, 101, 2)
42
随机浮点数：
>>> import random
>>> random.random()
0.85415370477785668
>>> random.uniform(1, 10)
5.4221167969800881
随机字符：
>>> import random
>>> random.choice('qiwsir.github.io')
'g
多个字符中选取特定数量的字符：
>>> import random
random.sample('qiwsir.github.io',3)
['w', 's', 'b']
>>> import random
>>> items = [1, 2, 3, 4, 5, 6]
>>> random.shuffle(items)
>>> items
[3, 2, 5, 6, 4, 1]
637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
