三元运算：
三元运算（三目运算），是对简单的条件语句的缩写。
# 书写格式
result = 值1 if 条件 else 值2
# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量
if a == 1:
name = "walker"
else:
name="wang"
name = "walker" if a == 1 else "wang" #一句话相当于上面的if else的意思lambda表达式：
def f1(a1)
return a1 +100
f1 = lambda a1:a1+100 #相当于上面的个函数,也可以加两个函数,但需要用逗号隔开函数：
1 def关键字,创建函数
2 函数名
3 ()
4 函数体
5 返回值
需要注意的是：
函数体是不被执行的,但会把函数体放入内存.只有在调用的时候才执行
写函数要先定义再调用
在函数中,一但执行了return,函数执行过程立即终止
函数传递参数的5种方式：
1 普通参数 (严格艳照顺序,将实际参数赋值给形式参数) 需要11对应
def func(a)
print(a)
#在调用的时候就要必须传参数进入函数，否则会报错
func("walker")
#或者
func（a="walker"）2 默认参数 (默认参数必须放置在参数列表的最后) 设置默认值
def func(a="walker",b="wang")
print(a,b)
#如果不传入参数到函数的话，函数将会采用默认参数赋值给a，也可以传入参数
func("wang","walker")
#或者
func（a="wang",b="walker"）3 指定参数 (将实际参数副职给指定的形式参数)
4 *变量 (可以传递无数个参数,传递完的参数被存为元组的形式)
def f1 (*args): #args是变量
print (args,type(args)) #args的类型是元组如果将列表传入的话,*列表的话,就将列表的每一个元素转换成元组在函数里.如果不加*就是将整个列表转换成元组的一个元素.
带*相当于一个for循环,将str或者元素里的每一个值都传至函数里.
5**变量 (可以传递无数个参数,传递完的参数被存为字典的形式)
传指定参数的时候(变量=vaule),在函数接收后,会将传入的参数转换成dict的格式.key=变量名,vaule=vaule
a=f1(n=1,m=2)
如果加2*传入函数(a=f1(**dic1))就会把字典的每一个元素都付给函数,函数接收参数后,会按照原字典的形式拼装6 万能参数 可以自动转换成,元组和字典.注意:在前面,*在后面
def f1=(*args,**kwargs) #一般都写成args,kargs 规范!
print (args)
print (kwargs)
f1(11,22,33,44,k1="v1,k2="v2") 可以自动识别元组类型或者是key,value类型7 补充
a. def f1
def f1 会用后面的参数
b.传递参数的时候是一个引用
c.全局变量和局部变量内置函数：
abs() #取绝对值
bool() #取布尔值 False的有(除了False))0,None,”“,[],{},()
all() #给all传参数,如果所有元素都为真就是真,有一个假久为假
n=all([1,2,3,4]) #print(n)的时候为Ture
n=all([1,2,3,0]) #print(n)的时候为Falseany() #给any传参数,任意一个为真就为真(具体参考all函数)
ascii() #自动执行对象的repr方法
bin() #接收10进制,转换成2进制 (0b表示2进制的意思)
oct() #接收10进制,转换层8进制 (0o表示8进制的意思)
hex() #接收10进制,转换层16进制 (0x表示16进制的意思)
int() #将字符串数字，转换成10进制
bytes() #把字符串可以转换成字节类型,想把一个字符串转换成一个字节。
bytes(s,encoding="utf-8")bytearray() #把btye的那种字节转换成列表
str() #把字节转换成字符串
str(字符串,encoding="utf-8")callable() #检测是否可以被执行 用处不大
chr() #ascii码对应关系
print(chr(65))ord() #跟chr相反,将字符转换成ascii码
print(chr(“A”))compile() #把字符串编译成代码
s="print(123)"
r=compile(s,"<string>","exec") #"<string>"可以被"文件名"替换exec() #执行compile()编译完的代码 比eval更牛逼，但是exec没有返回值
exec(r)eval() #eval函数可以计算Python表达式，并返回结果（exec不返回结果，
print(eval("…"))#打印None
#正确如下：
ret=eval("7+8+9")
print(ret)dir() #快速获取模块、类获取哪些功能
print(dir(dict))help() #相当于man文档,相当于按住ctrl鼠标左键显示的源码
help(dict)divmod() #取余数
r=divmod(97,10)
print r #r[0]是商 r[1]是余数
n1,n2=divmod(97,10) #可以将商和余数分别赋值给n1，n2enumerate() #用于遍历序列中的元素以及它们的下标 字典、列表、元组都可以
for i,j in enumerate(('a','b','c')):
print i,j
#以下为显示：
0 a
1 b
2 cisinstance() #判断对象是谁的实例
s="alex"
isinstance(s,str)filter() #(函数,可迭代的对象)
li=[11,22,33,44,55]
def f2(a): #f2=lambda a:a>22
if a>22:
return True
ret=filter(f2,li)
#ret=filter(lambda a:a>22,li) 用lamba表达式
#filter内部会循环第二个参数,在每一次循环的内部再执行第一个参数(把第二个参数传入第一个函数变量中)
print(list(li))map()#(函数,可迭代的对象），将第二个参数传入第一个函数，函数进行计算
result=map(lambda a:a+100,li)
print (list(result))frozenset() #不可变集合
globals() #可以打印出所有的全局变量
locals() #可以打印出所有的局部变量
hash() #生成哈希值
iter() #创建迭代器
len() #查看长度 python3里按照字符，python2按照字节
#如果要看字节长度 需要用bytes()max() #列出最大
min() #列出最小
sum() #列出求和
memoryview() #查看内存地址的
object() #所有类的父类
pow() #pow(2,10) 相当于2**10
range() #范围
reverse() #反转 reverse(li) == li.reverse()
round() #四舍五入
set() #集合
slice() #切片
sorted() #排序 sorted(li) == li.sorted()
vars() #当前模块都有哪些变量
zip() #负责将多个元素的相同角标内的内容，整理到一个元祖中。
join() #负责将同元组或者列表内的元素拼接起来 (“”.join(元祖或列表))
#注意，join拼接的只能是字符串，如果是int会报错
a=["walker","wang"]
print （"".join(a)）
更详细的官方资料：猛戳这里
open函数：open()
打开文件：
f=open("db","a") #如果open打开文件乱码了就增加encoding参数传入到open函数
r:只读
w:只写,每次都会把文件清空
x:如果当这个文件存在的时候就报错,不存在的话就创建并写内容
a:追加
rb:打开方式如果加了b(rb,wb,xb,ab) python不处理转换，读取的时候是字节类型,写入也是以字节类型写入 （常用于夸平台操作）
r+:+号可以即可读又可写(日后推荐使用) (可以+b) 如果打开模式无b 则read是按照字符读取。受影响的read(1)操作文件：
f.seek() #调整指针的位置 按照字节
f.tell() #获取当前指针的位置 按照字节 推荐使用时：f.seek(f.tell())
f.read() #默认无参数读全部,如果有参数按照打开方式(有b按照字节，无b按照字符)
f.write() #写入文件
f.close() #关闭文件
f.fileno() #文件描述符，文件的数字形式
f.flush() #将f.write()后但没有close()的缓冲区内容写入到文件
f.deadable()#查看文件是否可读 返回True 和 False
f.readline()#只读取一行
f.truncate()#截断文件,根据指针位置
for line in f: #循环每一行
print line关闭文件：
f.close()
replace函数()
user.replace(“old”,”new”,[max])
old – 将被替换的子字符串。
new – 新字符串，用于替换old子字符串。
max – 可选字符串, 替换不超过 max 次
#举例：
str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);字符串格式化：
字符串格式化分为：百分号方式、format方式
百分号方式：%[(name)][flags][width].[precision]typecode
(name) 可选，用于选择指定的key
flags 可选，可供选择的值有:
+ 右对齐；正数前加正好，负数前加负号；
- 左对齐；正数前无符号，负数前加负号；
空格 右对齐；正数前加空格，负数前加负号；
0 右对齐；正数前无符号，负数前加负号；用0填充空白处
width 可选，占有宽度
.precision 可选，小数点后保留的位数
typecode 类型模式，此项为必选 例如（%s %d）
%s， 获取传入对象的__str__方法的返回值，并将其格式化到指定位置
%r， 获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
%c， 整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
%o， 将整数转换成 八 进制表示，并将其格式化到指定位置
%x， 将整数转换成十六进制表示，并将其格式化到指定位置
%d， 将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
%e， 将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
%E， 将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
%f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
%F， 同上
%g， 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
%G， 自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%%， 当字符串中存在格式化标志时，需要用 %%表示一个百分号注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
常用格式化(%s)：
tpl = "i am %s" % "walker"
tpl = "i am %s age %d" % ("walker", 18)
tpl = "i am %(name)s age %(age)d" % {"name": "walker", "age": 18}
tpl = "percent %.2f" % 99.97623
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
tpl = "i am %.2f %%" % {"pp": 123.425556, }format方式: [[fill]align][sign][#][0][width][,][.precision][type]
: 【可选】格式化选项
fill 【可选】空白处填充的字符
align 【可选】对齐方式（需配合width使用）
<， 内容左对齐
>， 内容右对齐(默认)
＝， 内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
^， 内容居中
sign 【可选】有无符号数字
# 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
， 【可选】为数字添加分隔符，如：1,000,000
width 【可选】格式化位所占宽度
.precision 【可选】小数位保留精度
type 【可选】格式化类型 (用冒号)
传入” 字符串类型 “的参数
s，格式化字符串类型数据
空白，未指定类型，则默认是None，同s
传入“ 整数类型 ”的参数
b，将10进制整数自动转换成2进制表示然后格式化
c，将10进制整数自动转换为其对应的unicode字符
d，十进制整数
o，将10进制整数自动转换成8进制表示然后格式化；
x，将10进制整数自动转换成16进制表示然后格式化（小写x）
X，将10进制整数自动转换成16进制表示然后格式化（大写X）
传入“ 浮点型或小数类型 ”的参数
e， 转换为科学计数法（小写e）表示，然后格式化；
E， 转换为科学计数法（大写E）表示，然后格式化;
f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
g， 自动在e和f中切换
G， 自动在E和F中切换
%，显示百分比（默认显示小数点后6位）常用格式化(format)：
#最基本的
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
#用*将列表传进来，如果传字典用**
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)生成6位随机码：(验证码)：
import random
li=[]
for i in range(6):
r=random.random.randrange(0,5) # 取0到4随机数
if r==2 or r==4:
tmp= random.randrange(0,9)
li.append(chr(tmp))
else:
tmp= random.randrange(65,91)
c=chr(tmp)
li.append(c)
result="".join(li)
print(result)装饰器：
装饰器: @ + 函数名 例如(@outer)
1.会自动执行outer函数,并且将其下面的函数名f1当作参数传递
2.将outer函数的返回值,重新赋值给函数(原有的函数的内存地址会被覆盖)
下面的例子说明 f1 函数被inder取代
def outer(func)
def inter(*args,**kwargs): #先输出新函数,再输出原函数,在原函数不变的基础上再执行新函数
pass
r=func(*args,**kwargs) #func() 其实是执行老的f1函数
return r #可以将原函数的返回值返回
return inder #不能加括号,加括号相当于返回 inder函数的返回值也就是None
@outer
def f1()
pass双层装饰器
@xx2
@xx1
def xx0 #编译是从下到上，但执行是从上到下。! 其实记住从上到下执行就行了。生成器：
函数里面有yield 调用时候通过for循环取
def func()
print(111) #第一次执行的时候会print 111 然后yield 1
yield 1
print(222) #第二次执行的时候会print 111 然后yield 1
yield 2
print(333) #第三次执行的时候会print 111 然后yield 1
yiele 3
ret = func()
r=ret._next_() #进入函数找到yield 获取yield后面的数据 , 每一个yield相当于一个停顿
print(r)迭代器：
相当于for循环在python中. for循环封装了迭代器. 迭代器相当于用next功能去取,用for循环取到最后一个不会报错.
递归:
一个函数调用另外一个函数
def func(n)
n+=1
if n >=4:
return "end"
return func(n)递归阶乘
def func(num)
if num == 1:
return 1
return num * func(num)
x=fun(7) #实际上就是1*2*3*4*5*6*7的值补充上一篇文章忘了提的–集合：
集合 set 无序、不重复的序列
创建集合:
s=set()
s1={123,456}
s2=set() 创建一个空集合
s3=set([11,22,33,4])s.add 增加元素
s.clear 清除所有内容
s3=s1.difference(s2) #s1的差集 并赋值给s3
s1.symmetric_update(s2) #S1的差集并覆盖掉s1
s3=s1.symmetric_difference(s2) #s1和s2对称差集,并赋值给s3
s1.symmetric_difference_update(s2) #s1和s2对称差集,并覆盖掉s1s1.discard 移除集合中的元素,不存在不报错
s1.remove 移除集合中的元素,不存在会报错
s1.pop() 随机移除集合中的某个元素 不推荐.(pop里无参数)
ret = s1.pop() #ret接收pop移除的元素s3=s1.intersection(s2) s1和s2的交集 并赋值给s3
s1.intersection_update(s2) s1和s2的交集 并覆盖掉s1s3=s1.union(s2) s1和s2的并集 并赋值给s3s1.update(列表\元组\字符串) 可以被迭代的对象,可以被FOR循环的对象
可以将列表内添加的值循环加入set内
但如果是字符串将会被拆分issubset 子序列
issuperset 父序列
例如: s1={11,22,33}
s2={22,33}
那么s2的{22,33}就是s1的子序列,同理反之父序列补充一下集合的概念：
集合:A{1234} B{2345}
交集:A和B共有的部分 {2345}
并集:属于A或者属于B的 {12345}
差集:只属于A但不属于B,叫做A的差集{5}
全集:AB的所有元素集合 {12342345}
对称差集:只属于A但不属于B,只属于B但不属于A {15}
补集:术语全集AB但不属于A的叫做A的补集{5}双下划线的默认方法(python自动调用)
li=[11,22,33] #list_init_
li() #list_call_
li[0] #list_getitem_
li[0]=123 #list_setitem_
def li [1] #list_delitem_
try/finally
举例：
try:
<语句>
finally:
<语句> #退出try时总会执行try语句子句形式表
except: 捕获所有异常
except name: 只捕获特定的异常
except name,value: 捕获异常和它的附加数据（将异常的信息保存到value，）
except (name1,name2): 捕获任何列出的异常
else: 如果没有异常
finally: 总是执行在shell中给print语句加颜色 31是红色字体,32是绿色字体 41是背景红色
\033[31;1m”文字”]\033[0m
1表示加深，
3开头表示字体颜色，
4开头表示背景颜色。两种颜色都设置，用分号隔开
print (\033[1;32;41m"文字"\033[0m)
1 加深
5 闪烁
31 红色
32 绿色
33 黄色
34 深蓝色
35 紫色
36 蓝色
37 灰色
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
