python之初级学习

一.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")

五、数据类型

1、数字

2 是一个整数的例子。
长整数 不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子。

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（长整型）
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

 

2、布尔值

　　真或假

　　1 或 0

3、字符串

　　name='pxb'

　　age=18

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()