一.python安装
1.下载安装包（本人使用python3.5.1）
https://www.python.org/downloads/
2.安装python-3.5.1.exe
本人下载的是python-3.5.1-embed-amd64.zip绿色版，解压直接就能打开python-3.5.1.exe
二、声明变量
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 以下关键字不能声明为变量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
三、用户名，密码输入
四、if··else判断语句
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#定义变量并赋值
age=25
#输入一个数字
guss_age=int(input("please input guss age："))
#如果比初始定义变量大，输出太大
if guss_age>age:
print( "too big")
#如果比初始定义变量小，输出太小
elif guss_age<age:
print( "too small")
#如果和初始定义变量一样，输出正确
else:
print ("currurt")
五、数据类型
2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子。
int（整型）
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
4、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)
tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。
一个序列作为另一个序列的元素
>>>s3 = [1,[3,4,5]]
空序列
>>>s4 = []
元素的引用
序列元素的下标从0开始：
>>>print s1[0]
>>>print s2[2]
>>>print s3[1][2]
由于list的元素可变更，你可以对list的某个元素赋值：
>>>s2[1] = 3.0
>>>print s2
如果你对tuple做这样的操作，会得到错误提示。
所以，可以看到，序列的引用通过s[<int>]实现， int为下标
其他引用方式
范围引用： 基本样式[下限:上限:步长]
>>>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], 那么最后一个元素不会被引用 （再一次，不包括上限元素本身）
字符串是元组
字符串是一种特殊的元素，因此可以执行元组的相关操作。
>>>str = 'abcdef'
>>>print str[2:4]
5、词典
常见的创建词典的方法:
>>>dic = {'tom':11, 'sam':57,'lily':100}
>>>print type(dic)
词典和表类似的地方，是包含有多个元素，每个元素以逗号分隔。但词典的元素包含有两部分，键和值，
常见的是以字符串来表示键，也可以使用数字或者真值来表示键（不可变的对象可以作为键）。值可以是任意对象。键和值两者一一对应。
比如上面的例子中，‘tom’对应11，'sam对应57，'lily'对应100
与表不同的是，词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。
>>>print dic['tom']
>>>dic['tom'] = 30
>>>print dic
构建一个新的空的词典：
>>>dic = {}
>>>print dic
在词典中增添一个新元素的方法：
>>>dic['lilei'] = 99
>>>print dic
词典元素的循环调用
dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}
for key in dic:
print dic[key]
在循环中，dict的每个键，被提取出来，赋予给key变量。
通过print的结果，我们可以再次确认，dic中的元素是没有顺序的。
词典的常用方法
>>>print dic.keys() # 返回dic所有的键
>>>print dic.values() # 返回dic所有的值
>>>print dic.items() # 返回dic所有的元素（键值对）
>>>dic.clear() # 清空dic，dict变为{}
另外有一个很常用的用法：
>>>del dic['tom'] # 删除 dic 的‘tom’元素
del是Python中保留的关键字，用于删除对象。
与表类似，你可以用len()查询词典中的元素总数。
>>>print(len(dic))
6、运算
数学运算
>>>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==6 # =， 相等
>>>print 8.0!=8.0 # !=, 不等
>>>print 3<3, 3<=3 # <, 小于; <=, 小于等于
>>>print 4>5, 4>=0 # >, 大于; >=, 大于等于
>>>print 5 in [1,3,5] # 5是list [1,3,5]的一个元素
逻辑运算
True/False之间的运算
>>>print True and True, True and False # and, “与”运算， 两者都为真才是真
>>>print True or False # or, "或"运算， 其中之一为真即为真
>>>print not True # not, “非”运算， 取反
可以和上一部分结合做一些练习，比如：
>>>print 5==6 or 3>=3
7、集合（set）
1>创建集合
>>>set('boy')
set(['y', 'b', 'o'])
2>集合添加
集合add方法：是把要传入的元素做为一个整个添加到集合中，例如：
>>> a = set('pxb')
>>> a.add('mqq')
>>> a
{'x', 'b', 'p', 'mqq'}
集合update方法：是把要传入的元素拆分，做为个体传入到集合中，例如：
>>> a = set('pxb')
>>> a.update('mqq')
>>> a
{'x', 'b', 'p', 'mqq'}
3>集合删除操作方法：remove
set(['pxb', 'python', 'mqq'])
>>> a.remove('pxb')
>>> a
{'python', 'mqq'}
8.三目运算和lambda表达式
1>三目运算（三元运算）
如果if后面的表达式为True，则执行if前的内容，否则，执行else后面的内容，例如：
name='pxb' if 1==1 else 'mqq'
print(name) 2>lambda表达式
第一部分定义"=lambda"之前为方法名，“：”之前为定义的参数（可为多个），“：”后面为方法内具体内容，例如：
f2=lambda a1,a2:a1+a2+100 ret=f2(10,9)
print(ret)
9.函数
1>.定义函数
python 的函数是由一个新的语句编写，即def，def是可执行的语句--函数并不存在，直到Python运行了def后才存在。
函数是通过赋值传递的，参数通过赋值传递给函数
def语句将创建一个函数对象并将其赋值给一个变量名，def语句的一般格式如下：
def function_name(arg1,arg2[,...]):
statement
[return value]
返回值不是必须的，如果没有return语句，则Python默认返回值None。
2>函数的命名规则
函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；
函数名是区分大小写的。
函数名不能是保留字。
3>函数的作用域
Python使用名称空间的概念存储对象，这个名称空间就是对象作用的区域， 不同对象存在于不同的作用域。下面是不同对象的作用域规则：
每个模块都有自已的全局作用域。
函数定义的对象属局部作用域，只在函数内有效，不会影响全局作用域中的对象。
赋值对象属局部作用域，除非使用global关键字进行声明。
#全局变量，所有的位置都可读
#局部变量，只在声明的函数内部可以用
#遇到同名的变量，优先读函数内部的，没有再去函数外部找
#如果对全局变量进行全新赋值，需要加 global
#定义全局变量为大写
def function(name,age):
print(name+age)
def function(name,age):
print(name-age)
function(30,18)
NAME='puxiaobing'
def function2():
age=18
global NAME
NAME="pxb"
print(age,NAME)
def function3():
age=20
#NAME="mqq"
print(age,NAME)
function2()
function3()
4>参数
def send(name1,name2,name3):
print("普通参数测试:",name1,name2,name3)
return True
#普通参数，一一对应
send('pxb','mqq','ld')
def send2(name1,name2,name3='ld'):
print("默认参数测试:",name1,name2,name3)
return True
#默认参数，如果有多个参数，默认参数放到参数列表最后
#可传参数量可以不传已经有默认参数的参数，2默认参数再传值。会覆盖原来的默认参数
send2('pxb','mqq')
def send3(name1,name2,name3):
print("指定参数设置:",name1,name2,name3)
return True
#指定参数，在调用函数时可以按照形式参数的名分别传入参数，先后顺序并不影响输出结果
send3(name1='pxb',name2='mqq',name3='ld')
def send4(*args):
print("动态参数测试:",args)
return True
#动态参数加“*”如果将参数的每个元素当成参数传入
list=['pxb','mqq','ld']
name='puxiaobing'
send4(*list)
send4(*list)
send4(*name)
def send5(*args,**kwargs):
print("动态参数测试:",args)
print("动态参数测试:",kwargs)
return True
#动态参数加“*”如果将参数的每个元素当成参数传入,输出值为列表
#动态参数加“**”如果将参数的每个元素当成参数传入,输出值为字典
#万能参数
list=['pxb','mqq','ld']
name='puxiaobing'
dict2={ 'k1':'v1','k2':'v2'}
print(dict2)
send5(*list,**dict2)
send5(11,22,33,44,k1='v1',k2='v2')
#字符串格式化练习
dict={"name":'pxb',"age":18}
str="I am {name},age {age}".format(**dict)
print(str)
str="I am {0},age {1}".format('pxb',18)
print(str)
str="I am {name},age {age}".format(name='pxb',age=18)
print(str)
str="I am {name},age {age}".format(age=18,name='pxb')
print(str)
10.内置模块函数
11.文件打开、操作
1>文件打开:
f = file(name[, mode[, buffering]])
入口参数: name 文件名
mode 选项,字符串
buffering 是否缓冲 (0=不缓冲，1=缓冲, >1的int数=缓冲区大小)
返回值 : 文件对象
mode 选项:
"r" 以读方式打开，只能读文件 ， 如果文件不存在，会发生异常
"w" 以写方式打开，只能写文件， 如果文件不存在，创建该文件；如果文件已存在，先清空，再打开文件
"rb" 以二进制读方式打开，只能读文件 ， 如果文件不存在，会发生异常
"wb" 以二进制写方式打开，只能写文件， 如果文件不存在，创建该文件；如果文件已存在，先清空，再打开文件
"rt" 以文本读方式打开，只能读文件 ， 如果文件不存在，会发生异常
"wt" 以文本写方式打开，只能写文件， 如果文件不存在，创建该文件；如果文件已存在，先清空，再打开文件
"rb+" 以二进制读方式打开，可以读>写文件 ， 如果文件不存在，会发生异常
"wb+" 以二进制写方式打开，可以读>写文件， 如果文件不存在，创建该文件；如果文件已存在，先清空，再打开文件
2>关闭文件
f.close()
当文件读写完毕后，应关闭文件。
3>清空文件内容
f.truncate()
注意：仅当以 "r+" "rb+" "w" "wb" "wb+"等以可写模式打开的文件才可以执行该功能。
4>文件的指针定位与查询
（1）文件指针：
文件被打开后，其对象保存在 f 中， 它会记住文件的当前位置,以便于执行读>写操作，这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。
（2）文件打开时的位置:
以"r" "r+" "rb+" 读方式, "w" "w+" "wb+"写方式 打开的文件，
一开始，文件指针均指向文件的头部。
(3) 获取文件指针的值:
L = f.tell()
(4) 移动文件的指针
f.seek( 偏移量, 选项 )
选项 =0 时， 表示将文件指针指向从文件头部到 "偏移量"字节处。
选项 =1 时， 表示将文件指针指向从文件的当前位置，向后移动 "偏移量"字节。
选项 =2 时， 表示将文件指针指向从文件的尾部，，向前移动 "偏移量"字节。
5>从文件读取指内容
（1） 文本文件（以"rt"方式打开的文件）的读取
s = f.readline( )
返回值： s 是字符串，从文件中读取的一行，含行结束符。
说明： (1) 如果 len( s ) =0 表示已到文件尾
(2) 如果是文件的最后一行，有可能没有行结束符
2 二进制文件（以"rb">"rb+">"wb+" 方式打开的文件）的读取
s = f.read( n )
说明： (1) 如果 len( s ) =0 表示已到文件尾
(3) 文件读取后，文件的指针向后移动 len(s) 字节。
（4）如果磁道已坏，会发生异常。
6>向文件写入一个字符串
f.write("pxb")
参数： "pxb" 要写入的字符串
说明： (1)文件写入后，文件的指针向后移动 len(s) 字节。
（2）如果磁道已坏，或磁盘已满会发生异常
返回值： s 是字符串，从文件中读取的内容
7>删除文件
import os
os.remove(file)
12.python之装饰器
函数引用
1. 其可以被赋给其他变量
2. 其可以被定义在另外一个函数内
这也就是说，函数可以返回一个函数，看下面的例子：
def getTalk(type="shout") :
# 我们定义另外一个函数
def shout(word="yes") :
return word.capitalize()+" !"
def whisper(word="yes") :
return word.lower()+"...";
# 然后我们返回其中一个
if type == "shout" :
# 我们没有使用(),因为我们不是在调用该函数
# 我们是在返回该函数
return shout
else :
return whisper
# 然后怎么使用呢 ?
# 把该函数赋予某个变量
talk = getTalk()
# 这里你可以看到talk其实是一个函数对象:
print talk
#输出 : <function shout at 0xb7ea817c>
# 该对象由函数返回的其中一个对象:
print talk()
# 或者你可以直接如下调用 :
print getTalk("whisper")()
#输出 : yes...
还有，既然可以返回一个函数，我们可以把它作为参数传递给函数：
def doSomethingBefore(func) :
print "I do something before then I call the function you gave me"
print func() doSomethingBefore(scream)
#输出 :
#I do something before then I call the function you gave me
#Yes !
这里你已经足够能理解装饰器了，其他它可被视为封装器。也就是说，它能够让你在装饰前后执行代码而无须改变函数本身内容。
例如以下程序，用户登陆后每个功能操作都需要验证用户是否登陆，我们可以把验证模块作为装饰器：
def outer(func):
def inner(*args,**kwargs):
if LOGIN_USER['is_login']:
r=func()
return r
else:
print("请登录")
return inner
@outer
def order():
print("欢迎%s登陆"%LOGIN_USER['current_user'])
@outer
def changepwd():
print("欢迎%s登陆"%LOGIN_USER['current_user'])
@outer
def manager():
print("欢迎%s登陆"%LOGIN_USER['current_user']) def login(user,pwd):
if user=='pxb' and pwd=='123':
LOGIN_USER['is_login']=True
LOGIN_USER['current_user']=user
manager()
def main():
while True:
inp=input("1，后台管理 2，登陆")
if inp=='1':
manager()
elif inp=='2':
username=input("username:")
pwd=input("password:")
login(username,pwd) main()