python2
python的算法
3.0/2 --1.5
3.0//2 --1.0 地板除
5%2 --1 取余数
a=20 a+=20 --a=40 a%=4 -- =4
raw_input 获取一个数字
/usr/bin/python
a=int(raw_input(Please enter a number1:))
b=int(raw_input(number2:))
print(a+b)
print(a*b)
print(a-b)
print(a/b)
print(a%b)
--转译字符
斜杠转义字符 将特殊字符转译成普通字符(\)
say = "let's,\"go\""
换行\n
缩进\t·
cmp(a,b) 比较ab字符串是否相同 相同返回0，a>b返回1 a<b 返回-1
len(a) a长度
*重复 a=123 print a*3 --123123123
in 判断是否在 变量里面 是 true 否false
查看变量存储空间 id(a)
Python 现在存储空间存储一个字符串 并且定义一个标签 这个标签就是他的id
userinfo="wang 25 man" 如何取名称
userinfo[0:4] 这个很不方便 空格影响索引取值
--元组(tuple)
元祖可以很好的去规避这个问题
userinfo1=(wang,25,man)
userinfo1[1] --wang
userinfo1[2] --25
userinfo1[3] --man
a=(3) b=(3,) c=() type(a) --int type(b) --tuple type(c) --tuple
元组拆分
userinfo1=(wang,25,man)
name,age,gender=userinfo1
print(name) --wang
print(age) --25
a,b,c=(1,2,3) 多变量元素定义，一一对应
元组的特点 不可改变 存储数据安全性高
列表类型(list)
列表最大的特征可变的：list=['wang','jia','sen'] list[0] --wang
修改列表中的元素：
取值：切片和索引都可以 list[1] list[0:2] list[0:3:2]
修改元素：list[0]='wangwang' print list --['wangwang','jia','sen']
添加元素：list.append("17805121968") print list --['wangwang','jia','sen','17805121968']
删除元素：list.remove(list[3]) print list --['wangwang','jia','sen'] 注：list.remove('17805121968')
del(list[0]) print list --['jia','sen']
理解对象和类 对象=属性+方法 如：list1=[1,2,3,4,5] list = list1(定义的列表) + append (方法)
(使用点号来使用对象的方法：list.remove())
字典(type:dict)
t1=['name','age','gender']
t2=['wang','25','man']
print zip(t1,t2) --[('name','wang'),('age','25'),('gender','man')] 注：zip函数
格式：dict={key:value}
dict1={"name":"wang","age":24,"gender":"man"} print dict1['name'] --["wang"]
定义：a=123 b=456 dic3={a:'aaa','b':'bbb'} print dic3 --{123:'aaa','b':'bbb'}
访问字典： dic4={"name":"wang","age":24,"gender":"man"}
for k in dic4：
print k 返回 所有的key
for k in dic34
print dic4[k] 返回所有的 values
字典是可变的
增加字典：dic4={"name":"wang","age":24,"gender":"man"}
dic4['tel']='17805121968' print dic4 --{"name":"wang","age":24,"gender":"man",'tel':'17805121968'}
修改字典：
dic4['tel']='15755028513' print dic4 --{"name":"wang","age":24,"gender":"man",'tel':'15755028513'}
删除字典值：del(dic4['tel']) print dic4 --{"name":"wang","age":24,"gender":"man"}
dic4.pop('age') print {"name":"wang","gender":"man"}
清空字典：dic4.clear() print dic4 -- {}
删除字典：del(dic4) 注：del系统函数
工厂函数：zip
dict(zip('x','y'),(1,2)) 或者 dic(x=1,y=2) print {'x':1,'y':2}
copy 生成字典更快
dic4.get(3,'erro')
dic4.keys() dic4.values()
dict.fromkeys(seq,value)用法
如：seq=('name','age','gender')
dic6=dict.fromkeys(seq)
print dic6 --{'gender': None, 'age': None, 'name': None}
dic7=dict.fromkeys(seq,10)
print dic7 --{'gender': 10, 'age': 10, 'name': 10}
判断字典中是否在key --dict.has_key(key)
print dic4.has_key('age') --true
将字典返回出键值对元组的列表
print dic7.items() --[('gender',10),('age',10),('name',10)]
循环语句 -if else
逻辑判断 True 非空非0的 False 0或者None 空的量
定义一个函数： def fun()
return 10
if fun: --调用自定义函数fun 等同于 if 10：
print "OK"
def 和 if 的语法 注意“：” 缩进用4个空格代替
#!/usr/bin/python
def fun():
return 10
if fun()>2:
print "OK"
>> OK
else语法(第一个判断为False 择进行else判断)
#!/usr/bin/python
def fun():
return 10
if fun()<2:
print "OK"
else:
print "bad"
>> bad
#!/usr/bin/python
def fun():
return 0
x=int(raw_input("please input :"))
if x>=90:
print "A"
elif x>=80:
print "B"
elif x>=70:
print "C"
else:
print "D"
python3的判断语句
#！/usr/bin/python
def fun():
return 10
x=int(input("please inpute number:"))
if x>100:
print ("警告：请输入0~100的数字：")
elif x>=90:
print ("A")
elif x>=80:
print ("B")
elif x>=70:
print ("C")
elif x>=60:
print ("D")
else:
print ("不及格")
且的判断
if x>=90:
if y>=90:
嵌套判断：要求x大于等于90，并且y大于等于90 则输出
逻辑结构：and or not
if x>=90 and y>=90:
print ("A")
for i in I: 注：I为列表，i从列表中取元素，循环取元素，指导I列表元素耗尽
for x in "abcd"
print "hello world" --注意格式需要缩进
>>hello world
>>hello world
>>hello world
>>hello world
range函数
for i in range(a,b,c) a表示开始值 b表示结束值 c表示步进值 如 for i in range(1,100) 则循环100次
>>> for i in range(1,10,2):
... print i
...
1
3
5
7
9
>>>
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
列子：从1加到100
>>> num = 0
>>> for x in range(1,101):
... num += x
... print num
#!/usr/bin/python
s = "hellop"
for x in range(len(s)):
print s[x]
#!/usr/bin/python
s = "hellop"
l = [1,2,3,'a','b','c']
t = (7,8,9,'x','y')
for x in l:
print x
print t
遍历字典
#!/usr/bin/python
s = "hellop"
l = [1,2,3,'a','b','c']
t = (7,8,9,'x','y')
d = {1:111,2:222,3:333}
for x in d:
print d[x]
取字典里面的key
#!/usr/bin/python
s = "hellop"
l = [1,2,3,'a','b','c']
t = (7,8,9,'x','y')
d = {1:111,2:222,3:333}
for x in d:
print d[x]
print d.items() (键、值对)
>>
111
222
333
[(1, 111), (2, 222), (3, 333)]
#!/usr/bin/python
s = "hellop"
l = [1,2,3,'a','b','c']
t = (7,8,9,'x','y')
d = {1:111,2:222,3:333}
for x in d:
print d[x]
print d.items()
for k,v in d.itmes():
print k
print v
>>
111
222
333
1
111
2
222
3
333
python执行等待语法 导入模块 import time
time.sleep(5) --等待5秒执行下一个python语句
在for循环中，只要执行到break，循环将会结束，如果想要跳过本次循环：continue
#!/usr/bin/python
import time
for x in range(1,11):
print x
if x == 3:
pass #代码桩 -->如果这个if判断没有想要的结果，那么必须换行缩进，通常使用代码桩：pass
if x == 2:
print "hello 2"
continue -> 跳过循环 下面的循环不执行
if x == 6:
break
print "#"*10
else:
print "ending"
for x in range(1,11):
print "---------->",x
跳过一下所有代码包括for循环以外的语法(exit()):
#!/usr/bin/python
import time
for x in range(1,11):
print x
if x == 3:
pass #代码桩 -->如果这个if判断没有想要的结果，那么必须换行缩进，通常使用代码桩：pass
if x == 2:
print "hello 2"
continue -> 跳过循环 下面的循环不执行\
if x == 5:
exit()
if x == 6:
break
print "#"*10
else:
print "ending"
for x in range(1,11):
print "---------->",x
循环函数while
while Ture:
print "hello" -->这是死循环，因为输出结果后继续执行判定条件，因为条件为真，所有一直执行
#!/usr/bin/python
while True:
print "hello"
x = raw_input("please input something,q for quit:")
if x == "q":
break
输入q 结束
这个语法还有另外的写法
#!/usr/bin/python
x = "" -->必须定义一下x，否则while循环无法判断x是什么
while x != "q"
print "hello"
x = raw_input("please input something , q for quit :")
#!/usr/bin/python
x = ""
while x != "q":
print "hello"
x = raw_input("please input something,q for quit:")
if not x :
break
if x == "c":
continue -->如何为ture的话，跳过本次循环，不执行else
else：
print "ending..."
函数
第一节函数：
当我们自己定义一个函数时，语句：def(参数)
def plg():
如：def add():
c = a + b
print c
调用add()
#!/usr/bin/python
a = 100
def add():
if True:
print "good"
print a
add()
add()
--> good 100
good 100
因为print a 在def 语句里面 我调用了2次 所有打印2次
#!/usr/bin/python
def fun(x):
print "i get a :",x
s = raw_input("input something :")
fun(s)
#!/usr/bin/python
def fun(x,y):
if x == y:
print x ,"=" ,y
else:
print x ,"!=" ,y
m = raw_input("please input number1 :")
n = raw_input("number2:")
fun(m,n)
缺省参数： def fun(x=5,y="奶油味
变量：局部变量和全局变量的影响
#!/usr/bin/python
a = 100
def fun():
print a
fun()
def fun():
a = 100
print a
fun() -->这个a是局部变量 智能共定义函数使用
global 强制声明局部变量为全局变量
a = "wang"
def fun():
global a
a = 100
global b
b = 200
print (b)
fun()
print (a)
print (b)
这个语句中出现两个全局变量 语句按照顺序将全部变量修改了赋值
z = 10
def f(x,y):
print "welcome"
return x+y -->这个return用来返回这个函数的值得
调用这个函数：f(2,3) -->welcome 5
定义一个函数 z = f(2,3)
print z 打印z的值是自定义函数中return返回的值 输出结果为：5，
如果自定义函数没有return返回结果：
print z 输出结果为： 10
def f():
print x,y
t = ("a","b")
f(t) 这个是不成立的
def f(x,y):
print "%s : %s" % x,y -->注：第三个%号表示向引号里面传值，传的这个值就是%后面的
列： print "%s : %s : %s" % x,y,z
-->x:y:z
那么元组如何传：
t = (a,b)
def f(x,y):
print "%s : %s" % (x,y)
f(*t) --> a : b
注意：*号格式，如果元组中元素个数和打印的个数不一样，就会报错
如：
t = ('a','b','c')
def f():
print "s% : s%" % (x,y)
f(t)
这个语法是不正确的
def f(name="name",age=0):
print "name : %s" % name
print "age : %s" % age
f(wang,24) -->
name : wang
age : 24
f() 定义函数传参数为空，此时传的默认值
name : name
age : 0
t=(wangjiasen,25)
f(*t)
结果：
name : wangjiasen
age : 25
自定义函数传参格式：
向函数传元组合字典：
元组：fun(*args)
字典：fun(**kwords)
注意：元组传参数是有顺序的，字典传参数是无序的
def f(name = "name",age = 30):
print "name s%" % name
print "age s%" % age
d = {name = 'wangjiasen' , age = 25}
f(**d)
-—->name : wangjiasen
age : 25
如果字典中key和自定义函数中的变量不一样：
那么：
t = {'a' : 30,'b' : 'zhang'}
f(d['a'],d['b'])
常见的工作中，会遇到定义函数只需要传1个参数，但是传了超过1个参数的如何处理：
处理多余实参的语法：def fun(*args,**kw)
如：
def f(x,*args):
print x
print args
f(1)
--->1
()
f(1,2,3)
--->1
(2,3) 多余的参数将会生成元组
f(x=4)
--->4
()
f(x=4,y=5)这样的传参是无法传到元组的
那么：
def f(x,*args,**kwargs):
print x
print args
print kwargs
f(1)
--->1
()
{}
f(1,2,3,4,5,6,7)
--->
1
(2,3,4,5,6,7)
{}
f(x=1)
--->1
()
{}
f(x=1,y=2)
--->x
()
{'y' : 2}
def f(x,*args,**kwargs):
print x
print args
print kwargs
注意：这个定义函数中的变量为x 那么传的参数中要注意，出一个参数以外，后面的参数不能出现x
如：(1,2,3,4,x=10,y=20) 这个格式是不对的
匿名函数：lambda 可以使用在任何地方
def fun(x,y):
return x*y
print f(2,3)
---> 6
g = lambda x,y:x*y
print (g(2,3))
--->6
二者输出的结果一致
g = lambda x:x**2
冒号前面参数，冒号后面是公式
reduce为逐次操作list里面的每项
def f(n):
if n > 0:
n*f(n-1)
l = range(1,6)
l = [1,2,3,4,5]
def f(x,y):
return x*y
阶乘：
reduce(f,l)
--->120
同样
h = lambda x,y:x*y
reduce(h,l)
--->120
reduce(lambda x,y:x*y ,l)
--->120
语法switch：
python可以通过字典实现switch语句的功能
首先：定义一个字段
其次：调用字典的get()，获取相应的表达式
{1：case1，2：case2}.get(x,lambda *arg,**key:)()
#!/usr/bin/python
from __future__ import division
def jia(x,y):
return x+y
def jian(x,y):
return x-y
def cheng(x,y):
return x*y
def chu(x,y):
return x/y
def operator(x,o,y):
if o == "+":
print jia(x,y)
elif o == "-":
print jian(x,y)
elif o == "*":
print cheng(x,y)
elif o == "/":
print chu(x,y)
else:
pass
operator(2,'+',3)
---> 5
def jia(x,y):
return x+y
def jian(x,y):
return x-y
def cheng(x,y):
return x*y
def chu(x,y):
return x/y
operator = {"+" : jia ,"-" : jian, "*" : cheng, "/" : chu}
print operator ["+"](3,2)
--->5
print operator.get("%")(3,2)
def fun(x,o,y):
print operator.get(o)(x,y)
当需要if判断 都可以用字典来满足
内置函数：
绝对值：abs()
最大值：max()
最小值：min()
序列中原素长度：
l = "hello"
len(l) ---> 5
h = [1,2,4,5,6,7,8,9,0,11]
len(l) --->10
divmod()
pow()
round()
除法运算：
divmod(5,2)
--->(2,1) 商2余1
pow(2,3) ---> 8 2的3次方
pow(3,3,5) ---> 2 3的3次方除以5余2
四舍五入函数
round(9.98712,2) --->9.99
callable()
测试函数是否可被调用
callable(max) --->Ture
callable(m) ---> False
isinstance()
判断变量类型：
l = [1,23,4]
isinstance(l,list) ---> Ture
isinstance(l,int) --->False
cmp()
比对，相同返回0，不相同返回-1
range()
range(10)
xrange()
xrange(100) 用于高运算 其实就是一个列表
type int long float tuple str list 类型
str.capitalize()
("hello").capitalize() --->Hello 首字母大写
str.replace()
字符替换：("hello world")replace("hello",'good') ---> "good world"
ss="123123123"
ss.replace('1','x',2) --->x23x23123
str.split()
ip ="192.168.1.155"
ip.split('.')
['192','168','1','155']
ip.split('.',2)
['192','168','1.155']
综上格式：对象.函数
序列处理函数
filter()
def f(x):
if x > 5:
return True
l = [1,2,3,4,5,6,7,8,9]
过滤出大于5的数
filter(f,l)
--->[6,7,8,9]
zip()
map()
reduce()
模块--自定义模块：所谓的代码封装
divmod(5,2)
--->(2,1) 商2余1
pow(x,y)
格式：(x**y)
pow(x,y,z)
格式:(x**y%z)
round函数
