n = '路飞学诚'

print(n.encode('utf-8'))

# b'\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe8\xaf\x9a'

print(n.encode('utf-8').decode('utf-8'))

# 路飞学诚

print(n.encode('gbk'))

# b'\xc2\xb7\xb7\xc9\xd1\xa7\xb3\xcf'

print(n.encode('gbk').decode('gbk'))

# 路飞学诚

print(n.encode('gbk').decode('gbk').encode('utf-8'))

# b'\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe8\xaf\x9a'

print(n.encode('gbk').decode('gbk').encode('utf-8').decode('utf-8'))

# 路飞学诚

桃之夭夭，灼灼其华。之子于归，宜其室家。

桃之夭夭，有蕡其实。之子于归，宜其家室。

桃之夭夭，其叶蓁蓁。之子于归，宜其家人。

f = open('poem.txt', 'r+', encoding='utf-8')

f.seek(3*8)

print(f.read(1))

f.seek(3*28+2)

print(f.read(1))

data_list = f.readlines()

print(data_list)

data_list.pop()

print(data_list)

f.seek(0)

f.truncate()

f.write(''.join(data_list))

import time

def time_func(func):

    def wrapper(*args,**kwargs):

        time_start = time.time()

        func(*args,**kwargs)

        time_end = time.time()

        print(time_end-time_start)

    return wrapper

@time_func

def x(a,b):

    time.sleep(1)

    return a+b

x(1,8)

# 结果：1.0001220703125

# 带参数的装饰器

import time

def show_timw(func):

    def wrapper(a,b):

        start_time = time.time()

        ret = func(a,b)

        end_time = time.time()

        print("消耗时间为：%s" %(end_time-start_time))

        return ret

    return wrapper

@show_timw

def add(a,b):

    time.sleep(1)

    return a+b

print(add(48,45))

# 结果：

# 消耗时间为：1.0008337497711182

# 93

def test():

    print(luffy)

luffy = "the king of sea."

test()

# 结果：the king of sea.

def test():

      print(luffy)

      luffy = 'e'

test()

luffy = "the king of sea."

test()

li = [1,2,3,5,5,6,7,8,9,9,8,3]

res = (i*2 for i in li)

# print(list(res))

# 结果：[2, 4, 6, 10, 10, 12, 14, 16, 18, 18, 16, 6]

# print(next(res))

# 结果：2（一次取一个值）

for i in res:

    print(i)

# 结果：2

# 4

# 6

# 10

# 10

# 12

# 14

# 16

# 18

# 18

# 16

# 6

print(res.__next__())

# 结果：2

import logging

logging.basicConfig(filename='example.log', format='%(asctime)s - %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p', level=logging.DEBUG)

logging.warning('bug 24')

# 文件内容：

# 03/24/2018 08:52:36 PM - bug 24

import json,pickle  # json 可序列化的有 int str list tuple dict 没有集合

# pickle 可序列化python所有数据类型包括函数 pickle 可序列化一些类 但类需要引用

li = [1,2,3]

dict = {1,2,3}

def fun():

    return 3

str_data = json.dumps(li)

print(type(str_data),str_data)

# 结果：<class 'str'> [1, 2, 3]

list_data = json.loads(str_data)

print(list_data,type(list_data))

# 结果：[1, 2, 3] <class 'list'>

s = pickle.dumps(li)

print(s,type(s))

# 结果：b'\x80\x03]q\x00(K\x01K\x02K\x03e.' <class 'bytes'>

data = pickle.loads(s)

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

with open('test.txt','w',encoding='utf-8') as f:

    json.dump(li,f)

data = json.load(open('test.txt','r',encoding='utf-8'))

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

pickle.dump(li,open('test1.txt','wb'))

data = pickle.load(open('test1.txt','rb'))

print(data,type(data))

# 结果：[1, 2, 3] <class 'list'>

pickle.dump(fun,open('test2.txt','wb'))

data = pickle.load(open('test2.txt','rb'))

print(data())

# 结果：3

def fun1():

    n = 10

    def fun2():

        return n

    return fun2

f=fun1()

print(f())

# 结果：10

# 生成器:

s = (i for i in range(10))

print(next(s))

# 结果:0

# 迭代器:

def fun(n):

    x=0

    while(x<n):

        yield x

        x+=1

s = fun(3)

print(next(s))

print(s.__next__())

# 结果:0

# 1

from collections import Iterable,Iterator

print(isinstance({1,2,3},Iterable))

# 结果:True

s = iter([1,2,3,4,3,2,1])

print(s.__next__())

# 结果：

# 1

# 2

# 3

# 4

print(next(s))

# 结果：

# 1

# 2

# 3

# 4

for i in s:

    print(i)

# 结果：

# 1

# 2

# 3

# 4

# 3

# 2

# 1

def fun(x):

    n, a, b = 0, 0, 1

    while n < x:

        yield b

        a, b = b, a + b

        n += 1

res = fun(4)

# for i in res:

#     print(i)

# 结果：1

# 1

# 2

# 3

print(next(res))

print(next(res))

print(next(res))

print(next(res))

print(next(res))

# 结果：1

# 1

# 2

# 3

# StopIteration

print(globals())

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# <_frozen_importlib_external.SourceFileLoader object at 0x0000017306D6B080>, '__spec__':

# None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,

#                                                      '__file__':

# 'D:/exer.py', '__cached__': None}

print(locals())

# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':

# <_frozen_importlib_external.SourceFileLoader object at 0x0000017306D6B080>, '__spec__':

# None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,

# '__file__': 'D:/exer.py', '__cached__': None}

n1=[1,2,3]

def fun():

    n1[1] ='123'

    return n1

print(fun())

# 结果：[1, '123', 3]

print('n1是什么: ',n1)

# 结果：n1是什么:  [1, '123', 3]

res = map(lambda x:x*2,[1,2,3])

for i in res:

    print(i)

# 结果：

# 2

# 4

# 6

print(list(res))

# 结果：[2, 4, 6]

res = filter(lambda x:x%2==0,list(range(10)))

# for i in res:

#     print(i)

# 结果：

# 0

# 2

# 4

# 6

# 8

print(res.__next__())

# 结果： 0

print(next(res))

# 结果： 0

print(hash((1,2,3))) # 只有 不可变的才可哈希 int str tuple 如：list dict set 不能被哈希

# 结果：2528502973977326415

a = 2

b = 5

print(a if a>b else b)

# 结果：5

res =lambda a,b: a if a>b else b

print(res(2,3))

# 结果：3

fun = lambda x,y:x+y

print(fun(2,3))

# 结果：5

fun = lambda x,y:x if x>y else y

print(fun(2,3))

# 结果：3

res = map(lambda x:x*x,list(range(5)))

for i in res:

    print(i)

# 结果：

# 0

# 1

# 4

# 9

# 16

fun = lambda x,y:x/y if x>y else x*y

print(fun(4,3))

# 结果：1.3333333333333333

import time

import datetime

print(time.time())

# 结果：1521903163.3908226

print(time.asctime())

# 结果：Sat Mar 24 22:52:43 2018

print(time.gmtime())

# 结果：time.struct_time(tm_year=2018, tm_mon=3, tm_mday=24, tm_hour=14, tm_min=52, tm_sec=43, tm_wday=5, tm_yday=83, tm_isdst=0)

print(time.strftime('%Y-%m-%d %I:%M:%S %p',time.localtime()))

# 结果： 2018-03-24 10:52:43 PM

str_time =time.strftime('%Y-%m-%d %I:%M:%S %p',time.localtime())

# print(str_time)

# 结果：2018-03-24 10:52:43 PM

res = time.strptime(str_time,'%Y-%m-%d %I:%M:%S %p')

print(res)

# 结果：time.struct_time(tm_year=2018, tm_mon=3, tm_mday=24, tm_hour=22, tm_min=55, tm_sec=10, tm_wday=5, tm_yday=83, tm_isdst=-1)

print(time.mktime(res))

# 结果：1521903326.0

res =datetime.datetime.now() + datetime.timedelta(days=2,hours=3)

print(res)

# 结果：2018-03-27 01:55:43.520904

res1 = datetime.datetime.now().replace(year=2015,month=2,day=2)

print(res1)

# 结果：2015-02-02 22:55:58.174786

print(datetime.date.fromtimestamp(time.time()))

# 结果：2018-03-24

print(random.randint(1,3)) # 会包含3

print(random.randrange(1,3)) # 不会包含3

print(random.random())

print(random.choice('123123'))

import random

print(random.randint(1,3)) # 会包含3

print(random.randrange(1,3)) # 不会包含3

print(random.random())

print(random.choice('123123'))

# 结果：

# 3

# 1

# 0.8458542042848031

# 1

import string

# digits：获取所有的10进制数字字符

# punctuation：获取所有的标点符号

# ascii_letters：获取所有ascii码中字母字符的字符串（包含大写和小写）

print(''.join(random.sample(string.digits+string.punctuation+string.ascii_letters,6)))

# 结果：.uim4D

li = list(range(10))

random.shuffle(li)

print(li)

# 结果： [5, 2, 1, 7, 6, 3, 4, 8, 0, 9]

得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()

返回指定目录下的所有文件和目录名:os.listdir()

函数用来删除一个文件:os.remove()

删除多个目录：os.removedirs（r“c：\python”）

检验给出的路径是否是一个文件：os.path.isfile()

检验给出的路径是否是一个目录：os.path.isdir()

判断是否是绝对路径：os.path.isabs()

检验给出的路径是否真地存:os.path.exists()

返回一个路径的目录名和文件名:os.path.split()     e.g os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')

分离扩展名：os.path.splitext()       e.g  os.path.splitext('/usr/local/test.py')    结果：('/usr/local/test', '.py')

获取路径名：os.path.dirname()

获得绝对路径: os.path.abspath()

获取文件名：os.path.basename()

运行shell命令: os.system()

读取操作系统环境变量HOME的值:os.getenv("HOME")

返回操作系统所有的环境变量： os.environ

设置系统环境变量，仅程序运行时有效：os.environ.setdefault('HOME','/home/alex')

给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux and MAC使用'\n'

指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

重命名：os.rename（old， new）

创建多级目录：os.makedirs（r“c：\python\test”）

创建单个目录：os.mkdir（“test”）

获取文件属性：os.stat（file）

修改文件权限与时间戳：os.chmod（file）

获取文件大小：os.path.getsize（filename）

结合目录名与文件名：os.path.join(dir,filename)

改变工作目录到dirname: os.chdir(dirname)

获取当前终端的大小: os.get_terminal_size()

杀死进程: os.kill(10884,signal.SIGKILL)

sys.argv           命令行参数List，第一个元素是程序本身路径

sys.exit(n)        退出程序，正常退出时exit(0)

sys.version        获取Python解释程序的版本信息

sys.maxint         最大的Int值

sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform       返回操作系统平台名称

sys.stdout.write('please:')  #标准输出 , 引出进度条的例子， 注，在py3上不行，可以用print代替

val = sys.stdin.readline()[:-1] #标准输入

sys.getrecursionlimit() #获取最大递归层数

sys.setrecursionlimit(1200) #设置最大递归层数

sys.getdefaultencoding()  #获取解释器默认编码

sys.getfilesystemencoding  #获取内存数据存到文件里的默认编码

x = 10

def add(a, b=x):

    return a + b

ret = add(10)

print(ret)  # 输出 20

x = 20

ret = add(10)

print(ret)  # 输出 20 不是30 注意模块执行的流程 从上到下

# 2.lambda 的应用

# ---CASE 1

fs = map(lambda i:(lambda j: i*j), range(6))

print([f(2) for f in fs])

#---CASE 2

fs = [lambda j:i*j for i in range(6)]

print([f(2) for f in fs])

#---CASE 3

fs = []

for i in range(6):

    fs.append(lambda j:i*j)

    if i==3:

        break

print([f(2) for f in fs])

#---CASE 4

fs = [(lambda i:lambda j:i*j)(i) for i in range(6)]

print([f(2) for f in fs])

# 结果：

# [0, 2, 4, 6, 8, 10]

# [10, 10, 10, 10, 10, 10]

# [6, 6, 6, 6]

# [0, 2, 4, 6, 8, 10]

    总共有5个级别，默认级别是WARNING，

    按照级别高低分别为CRITICAL    ERROR    WARNING  INFO DEBUG

2017-10-18 15:56:26,613 - access - ERROR - account [1234] too many login attempts

# 20，请配置logging模块，使其在屏幕和文件里同时打印以下格式的日志

# 2017-10-18 15:56:26,613 - access - ERROR - account [1234] too many login attempts

import logging

logger = logging.getLogger('mylog')

logger.level = logging.INFO

# 创建一个handler，用于写入日志文件

fh = logging.FileHandler('exer.log')

# 再创建一个handler，用于写入输出控制台

ch = logging.StreamHandler()

fh.level = logging.WARNING

ch.level = logging.ERROR

logger.addHandler(fh)

logger.addHandler(ch)

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(lineno)s %(message)s')

fh.setFormatter(formatter)

ch.setFormatter(formatter)

logger.debug('too many login attempts')

logger.info('too many login attempts')

logger.warning('too many login attempts')

logger.error('too many login attempts')

logger.critical('too many login attempts')

    json：转化的数据类型，int str list tuple dict 不支持set

    json只可以用于字符串或者字典等与python数据类型之间的序列化与反序列化之间的操作

    pickle：支持python里面所有的数据类型，只能在python里使用，函数也可以序列化

    pickle可以用于python类有类型与python数据类型之间的序列化与反序列化的操作

    shelve：pickle封装了shelve，只能在python里使用，也就是说shelve对pickle进行了包装，是一个键值对的形式，shelve模块很简单，只有一个open函数

    将内存的数据类型转化为字符串，使其能存储到硬盘上或者通过网络传输到远程，因为硬盘或者网络传输只接受bytes类型。

    JSON不仅是标准格式，而且比XML更快，而且可以在web页面直接读取，非常方便。

三种执行命令的方法：

    subprocess.run(*popenargs, input=None, timeout=None, check=False, **kwargs) #官方推荐

    subprocess.call(*popenargs, timeout=None, **kwargs) #跟上面实现的内容差不多，另一种写法

    subprocess.Popen() #上面各种方法的底层封装

    可读性高: 不熟悉这个项目的代码的人，一眼就能看懂目录结构，知道程序启动脚本是哪个

，测试目录在哪儿，配置文件在哪儿等等。从而非常快速的了解这个项目。

    可维护性高: 定义好组织规则后，维护者就能很明确地知道，新增的哪个文件和代码应该放

在什么目录之下。这个好处是，随着时间的推移，代码/配置的规模增加，项目结构不会混乱，

仍然能够组织良好。

python argument.py luffy

'''

Linux当前目录/usr/local/nginx/html/

文件名：index.html

'''

import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(index.html)))

print(BASE_DIR)

[DEFAULT]

[client]

port = 3306

socket = /data/mysql_3306/mysql.sock

[mysqld]

explicit_defaults_for_timestamp

port = 3306

socket = /data/mysql_3306/mysql.sock

back_log = 80

basedir = /usr/local/mysql

tmpdir = /tmp

datadir = /data/mysql_3306

default-time-zone = '+8:00'

# _*_ coding: utf-8 _*_ 

# 1.修改时区 default-time-zone = '+8:00' 为 校准的全球时间 +00:00

# 2.删除 explicit_defaults_for_timestamp

# 3.为DEFAULT增加一条 character-set-server = utf8

import configparser

# 创建ConfigParser实例

config = configparser.ConfigParser()

# 读取配置文件

res = config.read('my.ini')

print(res)

config.set('mysqld','default-time-zone ','+00.00')

config.write(open('my.ini','w'))

# 设置sections节点中，键名为options的值

config.remove_option('mysqld','explicit_defaults_for_timestamp')

config.write(open('my.ini','w'))

config.set('DEFAULT','character-set-server ','utf8')

config.write(open('my.ini','w'))

# 10，写一个6位随机验证码程序（使用random模块),

# 要求验证码中至少包含一个数字、一个小写字母、一个大写字母.

import random

import string

# ascii_letters:获取所有ascii码中字母字符的字符串（包含大写和小写）

# digits:获取所有的10进制数字字符

res = ''.join(random.sample(string.digits+string.ascii_letters,6))

# res = ''.join(random.sample(string.ascii_lowercase + string.digits, 6))

print(res)

<!DOCTYPE html>

<html lang="en">

<head>

   <meta charset="UTF-8">

   <title>luffycity.com</title>

</head>

<body>

</body>

</html>

# 11，利用正则表达式提取到 luffycity.com ，内容如下

import re

with open('str.txt','r',encoding='utf-8') as f:

    data = f.read()

    print(data)

    res = re.search('\w+\.com',data).group()

    print("结果 ",res)

{"expire_date": "2021-01-01", "id": 1234, "status": 0, "pay_day": 22, "password": "abc"}

# 12，写一个用户登录验证程序，文件如下：1234.json

# {"expire_date": "2021-01-01", "id": 1234, "status": 0, "pay_day": 22, "password": "abc"}

# 　　

# 用户名为json文件名，密码为 password。

# 判断是否过期，与expire_date进行对比。

# 登陆成功后，打印“登陆成功”，三次登陆失败，status值改为1，并且锁定账号。

import os

import json

import time

def user_login():

    retry_count = 0

    while retry_count<3:

        account = input('\033[32;1mplease input Acount:\033[0m').strip()

        password = input('\033[32;1mplease input Password:\033[0m').strip()

        load_file(account)

        access_auth(account,password)

        retry_count += 1

    else:

        update_file(account)

def access_auth(account,password):

    account_data = load_file(account)

    if account_data['status'] == 0:

        if account_data['password']  == password:

            expire_time = time.mktime(time.strptime(account_data['expire_date'],'%Y-%m-%d'))

            if time.time() > expire_time:        #如果信用卡已经过期，当前时间戳大于国企的时间戳

                print("\033[31;1mAccount %s had expired,Please contract the bank"%account)

                exit()

            else:       #信用卡未过期，返回用户数据的字典

                return account_data

        else:

            print("\033[31;1mAccount or Passwordoes not correct!\033[0m")

    else:

        print("\033[31;1mAccount already be lock\033[0m")

        exit()

def load_file(account):

    file_name = '%s.json'%account

    if os.path.isfile(file_name):

        with open(file_name,'r',encoding='utf-8') as f:

            acc_data = json.load(f)

            return acc_data

    else:

        print("file [%s] does not exist"%account)

        exit()

def update_file(account):

    account_data = load_file(account)

    print(account_data)

    account_data['status'] =1

    print(account_data)

    file_name = '%s.json' % account

    with open(file_name, 'w', encoding='utf-8') as f:

        acc_data = json.dump(account_data, f)

user_login()

import json,time

count = 0

data = json.load(open('1234.json','r',encoding='utf-8'))

_username = '1234.json'

_password = data['password']

time_json = time.mktime(time.strptime(data['expire_date'],'%Y-%m-%d'))

time_now = time.time()

while count < 3:

    if data['status'] == 1:

        print('账号已锁定！')

        break

    elif time_now > time_json:

        print('账号已过期！')

        break

    else:

        name = input('name:').strip()

        password = input('password:').strip()

        if name == _username and password == _password:

            print('登录成功！')

            break

        else:

            print('请重新输入')

        count += 1

else:

    data['status'] = 1

    json.dump(data,open('1234.json','w',encoding='utf-8'))

{"expire_date": "2019-03-01", "id": 1234, "status": 0, "pay_day": 22, "password": "900150983cd24fb0d6963f7d28e17f72"}

import json,time,hashlib

count = 0

data = json.load(open('1234.json','r',encoding='utf-8'))

_username = '1234.json'

_password = data['password'] #abc

time_json = time.mktime(time.strptime(data['expire_date'],'%Y-%m-%d'))

time_now = time.time()

while count < 3:

    if data['status'] == 1:

        print('账号已锁定！')

        break

    elif time_now > time_json:

        print('账号已过期！')

        break

    else:

        name = input('name:').strip()

        password = input('password:').strip()

        if name == _username:

            m = hashlib.md5()

            m.update(password.encode())

            if m.hexdigest() == _password:

                print('登录成功！')

                break

        else:

            print('请重新输入')

        count += 1

else:

    data['status'] = 1

    json.dump(data,open('1234.json','w',encoding='utf-8'))

.

├── account

│   ├── luffy.json

│   └── tesla.json

└── bin

      └── start.py

   ------- Luffy Bank ---------

  1.  账户信息

  2.  转账

.

├── account

│   └── luffy.json

├── bin

│   └── start.py

└── core

   └── withdraw.py

   ------- Luffy Bank ---------

1.  账户信息

2.  提现

 .

 ├── account

 │   └── luffy.json

 ├── bin

 │   └── start.py

 └── core

 |   └── withdraw.py

 └── logs

     └── bank.log

unicode     包含所有国家的字符编码

utf-8         可变长的字符编码，英文表示一个字节，中文表示三个字节

ascii          美国标志信息交换代码，是基于拉丁字母的一套电脑编码系统。

                主要用于显示现代英语和其他西欧语言，一个字符占一个字节

gbk           全称，汉字内码扩展规范，一个字符占用两个字节

1 a = "alex"

2 b = a.capitalize()

3 print(a)

4 print(b)

执行结果：

1 alex

2 Alex

a.移除 name 变量对应的值两边的空格，并输入移除后的内容

print(name.strip()) #aleX

b.判断 name 变量对应的值是否以"al"开头，并输出结果

print(name.startswith('al')) #False

c.判断 name 变量对应的值是否以"X"结尾，并输出结果

print(name.endswith('X')) #False

d.将 name 变量对应的值中的“l”替换为“p”，并输出结果

print(name.replace('l','p')) #apeX

e.将 name 变量对应的值根据“l”分割，并输出结果。

print(name.split('l')) #['a', 'eX']

f.请问，上一题e分割之后得到值是什么类型（可选）

print(type(name.split('l'))) #<class 'list'>

g.将 name 变量对应的值变大写，并输出结果

print(name.upper()) #ALEX

h.将 name 变量对应的值变小写，并输出结果

print(name.lower()) #alex

i.请输出 name 变量对应的值的第 2 个字符？

print(name[1:2]) #l

j.请输出 name 变量对应的值的前 3 个字符？

print(name[:3]) #ale

k.请输出 name 变量对应的值的后 2 个字符？

print(name[-2:]) #eX

l.请输出 name 变量对应的值中“e”所在索引位置？

print(name.index('e')) #2

m.获取子序列，仅不包含后一个字符。如：oldboy则获取oldbo;root则获取roo

n1 = "oldboy"

n2 = n1.strip('y')

print(n2)  #oldbo

是

name = 'study'

for i in name:

    print(i)

# 结果：

# s

# t

# u

# d

# y

利用for循环来遍历一个列表（list）或元祖（tuple），将值依次取出，这种方法我们称为迭代

利用for语句迭代字符串，创建一个字符串，name = "deidai",然后用for语句进行迭代。

strr = "alexericrain"

pinjie = '_'.join(strr)

print(type(pinjie),pinjie)

# <class 'str'> a_l_e_x_e_r_i_c_r_a_i_n

li = ['alex','eric','rain']

pinjie = '_'.join(li)

print(type(pinjie),pinjie)

# <class 'str'> alex_eric_rain

sentence_input  = input("请输入：")

sensitive_varcabulary1 = str.maketrans("苍老师",'***')

sensitive_varcabulary2 = str.maketrans("东京热",'***')

new_sentence = sentence_input.translate(sensitive_varcabulary1).translate(sensitive_varcabulary2)

print(new_sentence)

# 请输入：dads大大的苍老师

# dads大大的***

import time

def timer(func):

def decor(*args):

start_time = time.time()

func(*args)

end_time = time.time()

d_time = end_time - start_time

print("run the func use : ", d_time)

return decor

@timer #printSth = timer(printSth) -> printSth = decor

def printSth(str, count):

for i in range(count):

print("%d hello,%s!"%(i,str))

printSth("world", 1000000)#run the func use : 4.414000034332275

s='hello'

l=[1,2,3,4]

t=(1,2,3)

d={'a':1}

set={1,2,3}

f=open('a.txt')

s='hello'     #字符串是可迭代对象，但不是迭代器

l=[1,2,3,4]     #列表是可迭代对象，但不是迭代器

t=(1,2,3)       #元组是可迭代对象，但不是迭代器

d={'a':1}        #字典是可迭代对象，但不是迭代器

set={1,2,3}     #集合是可迭代对象，但不是迭代器

f=open('test.txt') #文件是可迭代对象，但不是迭代器

#如何判断是可迭代对象，只有__iter__方法，执行该方法得到的迭代器对象。

# 及可迭代对象通过__iter__转成迭代器对象

from collections import Iterator  #迭代器

from collections import Iterable  #可迭代对象

print(isinstance(s,Iterator))     #判断是不是迭代器

print(isinstance(s,Iterable))       #判断是不是可迭代对象

#把可迭代对象转换为迭代器

print(isinstance(iter(s),Iterator))

info = 'Luffy'

res = info.swapcase()

f = open('test1.txt','w',encoding='utf-8')

f.write(res)

f.close()

"""This is the module docstring."""

def f(x):

    """This is the function docstring."""

    return 2 * x

>>> import mymodule

>>> mymodule.__doc__

'This is the module docstring.'

>>> mymodule.f.__doc__

'This is the function docstring.'