python学习

Python

关键点

解释性语言

记住：空行也是程序代码的一部分。

缩进相同的一组语句构成一个代码块，我们称之代码组。

Del+变量名 删除变量

运行第一个程序

def foo():     str="function"     print(str); def foo1(num):     print('num' ,num); def foo2(name ,age):     print('name' ,name);     print('age' ,age); if __name__=="__main__":     print("Hello world!")

 

数据类型

Numbers（数字）：不允许改变，改变意味着重新分配空间

Int，long，float，complex(复数)：21.2j

复数: 复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型

String（字符串）

var1='''zhaojunxia''' print("Hello world!") print(var1[4]) print(var1[3:6]) print(var1[-3:-7:-2])

字符串格式化

%c	格式化字符及其ASCII码	print 'my name is %s,i\'am %u years old and born in %d,my englishName is %c' %("zhao",12,-1994,'c')   str.format()格式化 print '{},{}'.format('hello','zhao') print '{0},{1},{0}'.format('hello','zhao') print '{name},{old}'.format(name="zhoao",old=12) info={'name':'zhao','old':12} print  '{name},{old}'.format(**info) newInfo=['li',122] print  '{0[0]},{0[1]}'.format(newInfo) class AssignValue(object):     def __init__(self, value):         self.value = value my_value = AssignValue(6) print('value : {0.value}'.format(my_value)) print("{:.2f}".format(3.1415926)); print("{:.0f}".format(3.1415926)); print("{:,}".format(10000)); print("{:.2%}".format(50/100.0)); print("{:<1d}".format(520)); print("{:^10d}".format(520)); print("{:>10d}".format(520));
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

 

自建函数

参考https://www.runoob.com/python/python-strings.html

 

List（列表）

list=[1,3,'za',1.3,'saa'] tinylist=['zuhe1','zuhe2'] print(list) print(list*2)#两次输出 print(list[2]) print(list[2:4]) print(list+tinylist) #合并列表

list.append('Google') ## 使用 append() 添加元素

Tuple（元组）

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。相当于list

list=(1,3,'za',1.3,'saa') tinylist=('zuhe1','zuhe2') print(list) print(list*2) print(list[2]) print(list[2:4]) print(list+tinylist) list[2]='2' #更新不合法

任意无符号的对象，以逗号隔开，默认为元组

x, y = 1, 2 print "Value of x , y : ", x,y

 

tuple(seq)   将列表转为list

Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合，字典当中的元素是通过键来存取的，而不是通过偏移存取。

dic={} dic['one']='zhao' dic[2]='jun' dic['name']='xia' tinyDic={'first':'li','last':'moxi'} print(dic) print(tinyDic) print(dic['one']) print(tinyDic['first']) print(dic.keys())#输出所有键 print(dic.values())#输出所有值 print(tinyDic.keys()) print(tinyDic.values())

运算符

算术运算符

运算符	描述	实例
**	幂 - 返回x的y次幂	x=3 y=4 z=x**y print(z)
//	取整除 - 返回商的整数部分（向下取整）	x=3 y=4 z=x**y j=y//x print(z) print(j)

 

比较（关系）运算符

<>不等于

赋值运算符

**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

逻辑运算符

And, or, not

print(x==y and x!=y) false print(x==y or x!=y) true print(not x==y) true

 

位运算符

X=3,y=4 print(x&y) 与，相应位都为1为1，否则为0 print(x|y) 或，相应位有一个为1为1 print(x^y)异或，相应位相异为1 print(~x)取反0变1,1变0 print(x<<2)向左移动两位，高位去除，低位补0 print(x>>1)向右移动两位

 

成员运算符

X=3,y=4 list={2,'zhao','li',5} print(x in list) print(x not in list)

 

身份运算符

身份运算符用于比较两个对象的存储单元,判断两个对象是否引用自相同的对象

x=3 y=4 print(x is y)  false print(x is not y)  true y=3 print(x is y) true print(x is not y) false

提示：

is 与 == 区别：类java中equal与==的区别

is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。

运算符优先级

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

条件语句

不支持switch，可以使用and，or之类嵌入到if语句中

 

循环语句

不支持do…while循环

循环控制语句

Break	终止循环，并跳出整个循环
Continue	跳出本次循环，执行下一次循环
Pass	pass是空语句，是为了保持程序结构的完整性

 

while循环

while x>0:     print(x)     x-=1 else:     print("sss")

while x>0:     print(x)     x-=1     if x==2:         break;  有break时不执行else else:     print("sss")

 

while … else（类似java的if…else） 在循环条件为 false 时执行 else 语句块,即执行完while循环进入else执行语句

简单语句组

while (flag): print 'Given flag is really true!'（无限循环不建议使用）

for循环

for …in

list=[2,'zhao','li',5] for li in list:     print(li)

 

for..else

list={2,'zhao','li',5} for li in list:     print(li) else:     print("sss")   #在执行完for循环后执行，同while…else

for index,li in enumerate(list):     if index==2:         break;  #有break时不执行else     print(li) else:     print("sss")

Pass语句

不做任何事情，用作占位

函数

math 模块：浮点数的数学运算函数

import math

 

print(dir(math))----》

['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

cmath 模块：复数运算的函数

import cmath

print(dir(cmath))----》

['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'isinf', 'isnan', 'log', 'log10', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

 

Time模块:时间函数

import time

time.time() 返回时间戳

Python函数用一个元组装起来的9组数字处理时间

序号	属性	字段	值
0	tm_year	4位数年	2008
1	tm_mon	月	1 到 12
2	tm_mday	日	1到31
3	tm_hour	小时	0到23
4	tm_min	分钟	0到59
5	tm_sec	秒	0到61 (60或61 是闰秒)
6	tm_wday	一周的第几日	0到6 (0是周一)
7	tm_yday	一年的第几日	1到366 (儒略历)
8	tm_isdst	夏令时	-1, 0, 1, -1是决定是否为夏令时的旗帜

time.localtime(time.time())本地时间---》time.struct_time(tm_year=2019, tm_mon=8, tm_mday=2, tm_hour=16, tm_min=46, tm_sec=23, tm_wday=4, tm_yday=214, tm_isdst=0)

time.asctime( time.localtime(time.time()) ) 格式化本地时间----》Fri Aug  2 16:47:30 2019

 

时间格式化---》time.strftime(format[, t])

 

字符串转时间戳---》time.mktime(time.strftime(format[, t]))

• 以下为处理时间模块，实际使用时斟酌使用
• datetime模块
• pytz模块
• dateutil模块
• calendar模块

数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

随机函数

函数	描述	实例
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。	list=[2,'zhao','li',5] random.seed(10)  #种子相同，生成的随机数相同 print(random.random()) print(random.choice(range(10))) print(random.randrange(2,5,2)) random.shuffle(list) print "list:",  list print(random.uniform(5,10))
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

三角函数

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

数字常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

 

自定义函数

def functionname( parameters ):

   "函数_文档字符串"

   function_suite

   return [expression]

def TestFunction(params1,params2):     params3=params1+params2;     print(params3) if __name__=="__main__":     TestFunction('''2''','''232323''');

 

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

def TestNotChangeParams(params):     params=3 if __name__=="__main__":     paramb=5     TestNotChangeParams(paramb);     print(paramb)     ----》5

 

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

def TestChangeParams(list):     list[2]='zhao' if __name__=="__main__":     list=['li',1212,'zj','sdsdsd']     TestChangeParams(list)     print(list)   ---》['li', 1212, 'zhao', 'sdsdsd']

关键参数与默认参数

def keyParams(name,age=12):     print('my name is %s ,i  am %d old' %(name,age)) if __name__=="__main__":     keyParams(name='zhao')     keyParams(name='zhao',age=25)     keyParams(age=23,name='zhao')

不定长参数

def noFixParams(name,*params):     print(name)     print(params) if __name__=="__main__":     list=['li',1212,'zj','sdsdsd']     noFixParams(23,list,'li') --》 23 (['li', 1212, 'zj', 'sdsdsd'], 'li')

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

表达式：lambda [arg1 [,arg2,.....argn]]:expression

sum=lambda arg1,arg2:arg1+arg2; if __name__=="__main__":     print(sum(1,14))

 

Return语句

def returnFun(param1,param2):     return  param1+param2 if __name__=="__main__":     num=returnFun(12,34)     print(num)

 

局部变量与全局变量

函数内为内部，函数外为全局变量

Global +变量名 在局部变量里，申明为全局变量

 

文件IO

输入

raw_input("按下 enter 键退出，其他任意键显示...\n")

str=input("expression:")   print(str)   ------》 expression:2*4 8

raw_input与input区别就是，后者可输入表达式并返回结果

打开和关闭文件

前置条件：

open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写

file object = open(file_name [, access_mode][, buffering])

• file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
• access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
• buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

 

file=open("../testIo.txt","a+") 打开文件，不存在时新建文件 file.write('insert new word,io stream') 写入文件 str=file.read(10); 读文件 print str position=file.tell() 获取文件当前位置 print(position) position=file.seek(0,1) 设置文件光标位置，第二个参数0为开头，1为中间，2为末尾 str=file.read(10) print str file.close() 关闭文件 print file.name  文件名称 print file.closed  文件是否关闭 print file.mode   文件读写模式 print file.softspace 文件强制空格 os.rename("../testIo.txt","../testIoReName.txt") 重新命名文件名称 open("../createNewFile.txt","a+")   os.remove("../createNewFile.txt")  移除文件 os.mkdir("../test")  新建目录 print  os.getcwd() 获取当前目录路径

File对象

详情https://www.runoob.com/python/file-methods.html

OS模块

详情https://www.runoob.com/python/os-file-methods.html

 

异常处理

异常类型

详情；

https://www.runoob.com/python/python-exceptions.html

 

捕获异常

try....except（捕获异常执行）...else（未捕获异常执行）

if __name__=="__main__":     try:         file=open("newFile.txt","r")  #文件没有写权限，抛出异常         file.write("zhaojskk")     except IOError:         print 'not find this file'     else:         print  file.name

 

try-finally 语句无论是否发生异常都将执行最后的代码。

if __name__=="__main__":     try:         file=open("newFile.txt","r")         file.write("zhaojskk")     except IOError:         print 'not find this file'     finally:         file.close()   #异常发生时也会关闭连接

raise语句自己触发异常  类似于java中的throw 自定义抛出异常

raise [Exception [, args [, traceback]]]

语句中 Exception 是异常的类型（例如，NameError）参数标准异常中任一种，args 是自已提供的异常参数。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。

a=10 b=input("input one num:") if(b==0):     raise Exception('bei chushu is not allowed is zero') else:     print a/b

面向对象

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了

 

python对象销毁(垃圾回收)

Python 使用了引用计数这一简单技术来跟踪和回收垃圾。

Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器

#encoding:utf-8 class Animal: #类名     __strType="animal" #类变量,两个下划线开头     countAnimals=0     def __init__(self,type,name,age):  #实例化对象时调用该方法，类java中的构造函数，self必须在此写，实例化时无需写         self.type=type         self.name=name         self.age=age         Animal.countAnimals+=1  #改不变类变量值         print 'i am an %s,my type is %s,my name is %s,my age is %d' %(Animal.strType,self.type,self.name,self.age)     def countAnimal(self): #类方法         print 'total animals is %d' %(Animal.countAnimals)  #调用类变量     def eat(self):         print 'my name is %s,i am eating now' %(self.name) class Dogs(Animal):     def __init__(self,Animal):         self.name=Animal.name         self.age=Animal.age         self.type=Animal.type         Animal.countAnimals+=1         print 'new children dogs'     def jump(self):         print 'i can jump'     def eat(self):#重写父类         print 'i am dogs,my name is %s,i am eating now' %(self.name) class Cats(Animal):     def __init__(self):         Animal.countAnimals+=1         print 'new children cates'     def sleep(self):         print 'i can sleep' if __name__=="__main__":     animal=Animal("dog","xiaoli",23)  #实例化对象     # animal.eat()  #调用对象方法     # animal.countAnimal()     # hasattr(animal,"name")  #是否包含属性，返回true或false     # getattr(animal,"age")   #获取属性值     # setattr(animal,"type","cat") #设置属性值，有则更新，无则新增     # print getattr(animal,"type")     # setattr(animal,"liu","23")     # print hasattr(animal,"liu")     # delattr(animal,"liu")  #删除属性值     # print hasattr(animal,"liu")     # print Animal.__doc__ #类的文档字符串     # print Animal.__dict__ #类的属性     # print Animal.__name__  #类名     # print Animal.__module__ #类定义所在的模块     # print Animal.__bases__ #类的所属父类构成的元素     dogs=Dogs(animal);     #print dogs.strType 报错，实例不能访问私有变量     dogs.countAnimals+=1;     dogs.countAnimal()     dogs.eat();     cats=Cats();     dogs.countAnimals+=1;     cats.countAnimal();

 

正则表达式

见https://www.runoob.com/python/python-reg-expressions.html#flags

CGI编程

 

见：https://blog.csdn.net/zhuanshu666/article/details/74936940