python 笔记3

于 2016-10-26 23:21:00 发布
阅读量125 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python json
原文链接：https://my.oschina.net/FrankXin/blog/776241

一、 内置函数

  • callable()    #判断传入参数是否为可执行函数
  • chr()           # 传入参数为整数返回对应的ASCII字符
r = chr(65)
print(r)

返回：
A
  • ord()          # 传入参数为asscii字符，返回对应的十进制
r = ord('c')
print(r)

返回：
99
  • 随机验证码实例
import random
li = []
for i in range(6):
    r = random.randrange(0,5)
    if i == 2 or i == 4:
        tmp = random.randrange(0,10)
        #注意写入时列表中必须为字符串
        li.append(str(tmp))
    else:
        tmp = random.randrange(65,91)
        b = chr(tmp)
        li.append(b)
print("".join(li))
  • compile()    #将字符串编译为代码（编译原理）
  • exec()     #执行代码
s = "print(123)"
r = compile(s,"<string>","exec")  #‘exec’,’eval’,’single’ 编码类型
print(r)
exec(r)

返回值
<code object <module> at 0x0000000001112930, file "<string>", line 1>
123
  • eval()        #计算字符串表达式，并返回值
s = "3*2"
print(eval(s))

返回：
6
  • dir()  #获取对象都提供那些功能
>>> dir(dict)
['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
  • divmod()    #可实现分页功能
>>> r = divmod(80,12)
>>> print(
... r)
(6, 8)

>>> r,b = divmod(80,12)
>>> print r,b
6 8


###########
如果是有80条数据，每页12条，需要分7页
  • isinstance()     #判断参数是不是对应的实例
>>> a = 'aa'
>>> isinstance(a,str)
True
>>> isinstance(a, list)
False
  • filter()    #循环第二个参数，让每个循环参数执行函数，如果参数合法则将内容打印出来
#!/usr/bin/python3
#简单函数写法
def f2(a):
    if a > 20:
        return True

li = [2,56,3,4,22,33]
print(list(filter(f2,li)))


------------------------
[56, 22, 33]

#lambda 写法
li = [2,56,3,4,22,33]
print(list(filter(lambda a: a > 4,li)))

-----------------------返回值
[56, 22, 33]
  • map()    # 第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。
# 将列表内每一个元素加100，两种写法
li = [2,56,3,4,22,33]
#第一种写法
def f1(a):
    ret = []
    for i in a:
        ret.append(i+100)
    return ret
print(list(f1(li)))

#第二种写法，使用map和lambda表达式
print(list(map(lambda a: a +100,li)))

---------输入结果----------
[102, 156, 103, 104, 122, 133]
[102, 156, 103, 104, 122, 133]
  • zip()       #将列表的每一个元素对齐放到一个元组中，实例如下
a = ['a',2,3]
b = ['b',2,3]
c = ['c',2,3]
la = list(zip(a,b,c))[0]
tem1 = ' '.join(la)
print(tem1)


---------输出--------------
a b c

二、装饰器

装饰器原则： 1. 不能修改源代码；2. 函数调用方式不能改变；

装饰器的作用就是为已经存在的对象添加额外的功能 ；

  • 组成 部署
  • @ + 函数名
  1. 自动执行outer函数，并且将其f1的函数名当做参数传递
  2. 将outer函数返回值，重复赋值给f1函数
def outer(func):
    def inter():
        print('123')
        r = func()
        print(456)
        return r
    return inter

@outer
def f1():
    print('abc')
    return 'bbc'

print('返回值',f1())


---------输出----------
123
abc
456
返回值 bbc
  • 装饰器参数   #当函数有传参时，则需要在装饰器内增加传参
def outer(func):
    def inter(*args, **kwargs):
        print('123')
        r = func(*args, **kwargs)
        print(456)
        return r
    return inter

@outer
def f1(arg,kwargs):
    print(arg,kwargs)
    return 'bbc'

print('返回值',f1('zzz','aaa'))


-------输出-------------
123
zzz aaa
456
返回值 bbc
  • 多层装饰器     
  • 通过多个装饰器来实现目的，一个函数应用一个装饰器时这段代码就会组成新的函数，再往上层添加一个装饰器，这就是多层装饰器， 即多个装饰器修饰同一个对象
# 用户登录系统
# 用户登录时分为管理员和普通用户，普通用户无法查看index里面内容，admin则都可以查看
# 每次访问都需要验证用户是否登录，是否有权限，代码实现如下：



USER_INFO = {}

def check_login(func):
    def inner(*args, **kwargs):
        if USER_INFO.get('is_login',None):
            ret = func(*args, **kwargs)
            return ret
        else:
            print('请登录')
    return inner

def check_admin(func):
    def inner(*args,**kwargs):
        if USER_INFO.get('user_type', None) == 2:
            ret = func(*args, **kwargs)
            return ret
        else:
            print('无权限登录')
    return inner

#多层装饰器实现
@check_login
@check_admin
def index():
    print('Index')

@check_login
def home():
    print('home')


def login():
    user = input('请输入用户名: ')
    if user == 'admin':
        USER_INFO['is_login'] = True
        USER_INFO['user_type'] = 2
    else:
        USER_INFO['is_login'] = True
        USER_INFO['user_type'] = 1

def main():
    while True:
        inp = input('1. login; 2. call user message; 3. admin \n>>>')
        if inp == '1':
            login()
        elif inp == '2':
            home()
        elif inp == '3':
            index()

main()

三、 字符串格式化

  • % 字符格式化
# 选择指定的key进行字符串格式化
message = "you name is %(name)s , you age is %(age)s" %{'name':'ww','age':10}
print(message)

------------输出-------------
you name is ww , you age is 10

# 百分号占位符 +左对齐，-右对齐，10表示一共占10个字符位置
message = "aaa%(name)+10sbbb" %{'name':'ww'}
print(message)
-------------输出-----------
aaa        wwbbb

# 字符串格式化只保留两位小数
message = "%(p).2f" %{'p':1.2345}
print(message)
-------输出-----------
1.23


#%c 将数字转换成其unicode对应的值
#%o 将整数转换成八进制表示
#%x 将整数转换成十六进制表示
message = "unicode:%c,8进制:%o, 十六进制:%x"%(65,15,15)
print(message)
-----------输出---------
unicode:A,8进制:17, 十六进制:f
  • format()   
  • 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位）
#名称字符串格式
message = "{name},{age}".format(name='aa',age=23)
print(message)
#基本字符串格式化
m1 = "{0},{1},{0}".format(11,22)
print(m1)
-----------输出-----------
aa,23
11,22,11

#使用*号填充站位11个,并且让字符串居中
m2 = "{:*^11s}".format('web')
print(m2)
--------------输出---------
****web****


#百分比格式输出,保留小数后两位
m3 = '{:.2%}'.format(0.0777)
print(m3)
————————输出--------
7.77%
  • 生成器    # 生成器不会把结果保存在一个系列中，而是保存生成器的状态，在每次进行迭代时返回一个值
#使用yield 来做生成器
def func():
    yield 1

ret = func()
print(ret,'ret')
# 循环时才会将结果打印出来
for i in ret:
    print(i,'i')

-------输出-------
<generator object func at 0x0000000001137888> ret
1 i

四、函数递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

# 递归执行函数体
def b():
    print('110')

def a():
    r = b()
    return r

a()
-------输出------------
110

# 执行函数体本身，当a满足条件时才会停止，每次执行时将a加1，直到大于等于111就返回
def func(a):
    a += 1
    if a >= 111:
        return 'end'
    return func(a)
ret = func(23)
print(ret)

--------输出--------
end

五、模块

  • python 模块的默认路径

#打印出python的默认路径
import sys

for i in sys.path:
    print(i)
----------------------
/usr/lib/python2.7
/usr/lib/python2.7/plat-x86_64-linux-gnu
/usr/lib/python2.7/lib-tk
/usr/lib/python2.7/lib-old
/usr/lib/python2.7/lib-dynload
/usr/local/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages/PILcompat
/usr/lib/pymodules/python2.7
  • 向python默认模块的路径里面添加路径
>>> for i in sys.path:
...     print i
... 

/usr/lib/python2.7
/usr/lib/python2.7/plat-x86_64-linux-gnu
/usr/lib/python2.7/lib-tk
/usr/lib/python2.7/lib-old
/usr/lib/python2.7/lib-dynload
/usr/local/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages/PILcompat
/usr/lib/pymodules/python2.7
# 添加/root目录
>>> sys.path.append('/root')
>>> for i in sys.path:
...     print i
... 

/usr/lib/python2.7
/usr/lib/python2.7/plat-x86_64-linux-gnu
/usr/lib/python2.7/lib-tk
/usr/lib/python2.7/lib-old
/usr/lib/python2.7/lib-dynload
/usr/local/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-packages/PILcompat
/usr/lib/pymodules/python2.7
/root
  • 创建模块名称的时候，不要和内置模块一样

六、序列化和反序列化

  • 序列化是把数据类型转换为字符串，反序列化是将字符串转换为数据类型
  • json 好处是可以跨语言
####序列化 json.dumps()

import json

date = {'k':'v'}

print(date,type(date))

ret = json.dumps(date)

print(ret,type(ret))

-----输出------
{'k': 'v'} <class 'dict'>
{"k": "v"} <class 'str'>



####反序列化 json.loads()
####注意字符串内数据必须用 双引号 ，否则会报错
import json

date = '{"k":"v"}'

f1 = json.loads(date)

print(f1,type(f1))
-----输出-----
{'k': 'v'} <class 'dict'>
  • dump(), load()    #相对于dumps跟loads的区别是增加了一个读文件和写文件
import json

li = [1,2,3,4,5]
#进行序列化时,将内容写入到文件中
json.dump(li,open('db','w'))

#反序列化时，读取文件内容并返回
ret = json.load(open('db','r'))
print(type(ret),ret)

------输出-----------
<class 'list'> [1, 2, 3, 4, 5]
  • pickle 序列化，只适用于python，趋向于更复杂的python操作

转载于:https://my.oschina.net/FrankXin/blog/776241

chuoding3576
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值