【笔记-python】python

1. 安装

环境变量path：  python所在路径 及python路径下\Scripts

文本文件a.py

命令行python a.py执行

直接运行phython可以进入phython命令行，直接输入执行语句

Python命令行参数

选项	描述
-i	python  -i  t.py 运行t.py文件后不立即退出python shell
-h	python  -h 显示帮助信息
-V	输出Python版本号

Lib\idlelib\idle.bat可以启动python自带的gui编程环境

1. 包管理

Scripts文件夹下pip.exe可以进行包管理

可以将包安装到  \Lib\site-packages 下

pip install **       安装***

pip list               列出已经安装的包

包文件夹中包含__init__.py，可以为空

该文件在import模块时执行

lib下载地址:

https://www.lfd.uci.edu/~gohlke/pythonlibs/

（关键字edu whl）

1.下载whl文件后缀改为zip解压后直接拿出即可

2.pip install ***.whl

1. 导入包

from Tkinter import *    

from aaa.def import  *   从aaa包中导入其中def.py内的所有内容

import math

import math  as  mt      导入包并重新命名

1. 声明

#coding=utf-8则支持中文

str.decode('utf-8').encode('gbk')      //字符串输出时使用

#!/usr/bin/python

告诉操作系统执行这个脚本的时候，调用/usr/bin下的python解释器
这种用法是为了防止操作系统用户没有将python装在默认的/usr/bin路径里。当系统看到这一行的时候，首先会到env设置里查找python的安装路径，再调用对应路径下的解释器程序完成操作。

#!/usr/bin/env  python 3.3

1. 注释

#注释

1. doc

def fun(x):
    """this is doc"""
    print(x)

print(fun.__doc__)

1. 语句格式

a = 1

b = 2.3

c = a+b

变量无类型

语句不需要分号结束

依靠排版区分语句

区分语句作用域用Tab

两个语句在同一行使用分号隔开

行连接保留第二行空格

str = "a\

   def"

1. 数据类型

int,float,bool,complex

bool对应True 和 False

 4+2j   complex

type(*)  获取数据类型

type(*) == type(1) 可以判断*是否和1是相同的类型

1. 类型转换

int(x )                          将x转换为一个整数    

long(x)                        将x转换为一个长整数    

float(x )                       将x转换到一个浮点数    

complex(real [,imag ])  创建一个复数    

str(x )                  将对象 x 转换为字符串    

repr(x )                将对象 x 转换为表达式字符串    

eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象    

tuple(s )               将序列 s 转换为一个元组    

list(s )                将序列 s 转换为一个列表    

chr(x )                 将一个整数转换为一个字符    

unichr(x )              将一个整数转换为Unicode字符    

ord(x )                 将一个字符转换为它的整数值    

hex(x )                 将一个整数转换为一个十六进制字符串    

oct(x )                 将一个整数转换为一个八进制字符串   

数字转字符串

s = str(12)

字符串转数字【s.isdigit()】

f = float(s)

i = int(s)

字符转数字

ord(c)

数字转字符

chr(i)

1. 运算符

无自增运算

连续赋值

a,b = 3,3+1

a = 2**3          #2的幂运算   2*2*2

a = 3//2.0          #取整运算

a = 3%2            #取余

逻辑运算符:

not/and/or(没有!,||,&&)

结果 True 和 False

1. 语句结构
   1. 选择

# coding=utf-8

score = 75

if score>90:

    print("优秀")

elif score>60:

    print("合格")

else:

print("不合格")

1. 1. 循环

yyy在循环结束后输出，range最后一个参数可以定义step

for i  in range(1,10):

print("item{0}:{1}".format(i,i + 0.3))

print("yyy")

a = 0

while a < 10:

print(a)

a+=1

1. 函数

def fun(a,b=5):

   if a > b:

      return a

   else:

      return b

   

print(fun(2,4))

1. Class

_xxx          保护成员

__xxx        私有成员

__xxx__     系统定义名字

dir(类名)   获取类中的属性和方法

1. 1. 定义

class CC:

   val = 10

   def __init__(self,_name):

       self.name = _name

   def show(self):

       print(self.name)

       print(self.val)

使用：

c = CC("abc")

c.show()

类内函数第一个参数都是类的对象

类的成员变量可以通过self.** 直接创造

__init__  构造函数

1. 1. 继承

class DD(CC):

   def __init__(self,nn):

        CC.__init__(self,nn)

   def Sw(self):

       print(self._name)   

d = DD("yy")

d.Sw()

1. 异常
   1. 异常处理

try:
    val = dic[7]
except (KeyError,TypeError) as erro:  #或者except Exception as e:
    print(" : %s"%erro)

else:

    无任何异常时执行

1. 1. 抛出异常

raise Exception("抛出一个异常")

1. 字符串     
   1. 编码转换

默认utf-8

cstr=str.encode(“gbk”)

1. 1. 引号使用

单引号中可以包含双引号，双引号中可以包含单引号

c = 'abc'

d = 'it is a "apple"'

e = "it's a dog"

三引号支持换行，保留编辑时的换行格式 （三个单引号或者三个双引号）

f = '''it

is

a

dog'''

1. 1. 转义

字符串前加r，字符串中\n之类的转义字符可以当作普通字符

路径可以使用

f = r"abc\ndef"

1. 1. 字符串重复

字符串重复10次

"abc\n"*10

1. 1. 截取字符串

c = "abcdefg"

f1 = c[1]      #取1位置，结果b

f2 = c[1:]     #取1位置及之后所有，结果bcdefg

f3 = c[:3]     #从0位置取到3位置结束，结果abc

f4 = c[1:3]   #从1位置取到3位置，结果bc

1. 1. 格式化字符串

s = "val:%d,%.2f,%s"% (12,1.523,"abc")

s = "val:{0},{1},{2}".format(12,1.5,"abc")

%5s    表示字符串至少5个字符，如果不够则前面空格补齐

%-5s   表示字符串至少5个字符，如果不够则后面空格补齐

1. 1. 拆分

str.split(",")   返回列表[]

1. 1. 判断是否是整数

str.isdigit()

1. 1. 查找

str.find("de",0,6)   后两个参数表示从查找范围，可以省略

str.index("de")   如果找不到会报错

返回查找到的下标，-1表示没有找到

1. 1. 连接字符串

str.join("def")

1. 1. 替换

str = str.replace(".zip","")

1. main

if __name__ == "__main__":

print "xxx"

每个文件都由一个模块名__name__，如果是被import__name__为文件名。如果是运行开始的文件则为__main__

使用if可以让内容只在该文件被启动运行时执行，而该模块被调用时不执行

1. pass

def fun():

pass

#to do

方法或类下不能为空，使用pass起占位作用

1. 装饰器

def TestFun(fun):
    fun(10,20)

@TestFun
def fun(a,b):
    print(a+b)

通过@引用一个调用当前函数的函数

1. 数据集
   1. 元祖

arry = (123,"abc",12.4)

arry = tuple( (123,"abc",12.4) )

arry[1]      #元素“abc”

内容不能修改，只能读取

1. 1. 列表

arry = [123,"abc",12.4]

arry  = list([123,"abc",12.4])

Arry = list("abc")

str = arry[1]    #访问元素“abc”

del li[1]   #删除元素“abc”

arry[-1]  #访问倒数第一个元素12.4

arry[1]=22 #修改元素

arr.append(3) #添加元素

l.sort() #排序

arry   = arry * 4 #元素变四倍

1. in  arry   #元素是否在集合中

遍历：

for obj in arry:

#生成顺序序列

arry = range(len(xNames))

1. 1. 集合

s1 = set("abccd")

s2 = {'b','c','x','c'}

#只保留序列中非重复内容,去重

构造函数只能加入序列

#添加元素

s.add(3)

#交集             结果：b，c

x = s1 & s2

#并集          合起来不重复的元素     结果：a b c d x

y = s1 | s2

#差集         s1中去掉和s2的交集    结果：a d

z = s1 - s2

1. 1. 字典

dic = {"str":1.2, 3.1:4}

dic =dict(  {"str":1.2, 3.1:4} )

#修改元素，如果字典内有，则进行访问

dic['str'] += 5

#插入元素，如果字典内没有，则插入新值

dic[33] = 111

print(dic[33])

=========查找  

if 5 in dic:

=========遍历

for key,value in dic.items():
    print key,value

for key in dic:
    print key,dic[key]

=========获取set

s = set(dic.values());
s2 = set(dic.keys());

=========字符串格式化

dic = {"str1":1.2, "str2":"aaa"}
ss = "%(str1)f  %(str2)s"%dic
print(ss)

1. 1. 运算方法

元素个数  len(arr)

最小值     min(arr)

最大值     max(arr)

求和        sum(arr)

1. lambda

结果要用*ret进行取值

1. 1. 操作每个元素

为每个元素执行相同操作

li = [1,2,3,4,5,6]
ret = map(lambda x: x*100,li)

1. 1. 排序

class student:
    def __init__(self,age,name):
        self.age = age
        self.name = name
arry = (student(11,'a'),student(4,'b'),student(10,'x'))

对类中的age进行排序

ret = sorted(arry,key=lambda x:x.age)
for stu in ret:
    print(stu.age)

1. 1. 过滤数据

只保留满足条件（x%2==0）的数

li = [1,2,3,4,5,6]
ret = filter(lambda x: x%2==0,li)

arry = ('xxx','abcxxxdef','xyz','x.x','axxxxxxa')

完全匹配：
ret = filter((lambda x: re.match(r'xxx',x)),arry)

匹配包含字符串的内容：

ret = filter((lambda x: re.search(r'xxx',x)),arry)

只匹配x.x

ret = filter((lambda x: re.search(r'x\.x',x)),arry)

1. 1. 列表解析

从列表中获取满足条件的元素

li = [1,2,3,4,5,6]
ret = [x for x in li if x%2==0 ]

1. Py文件交互

在b文件中存在类CC

class CC:

   def fun(self):

      print("cc")

其他文件使用时

====导入文件

import  b

c = b.CC()

c.fun()

====导入文件中的类

from b import CC

c = CC()

c.fun()

======函数调用

在b文件中只存在fun函数时

import b

b.fun()

======执行代码

如果b文件中有执行代码，被其他文件导入，因为导入在文件上面，所以b文件中的代码首先执行

1. 输入输出

a = input("输入a:")               

i = int(raw_input("input:"))

print(a)

print (a,b,c)