def my_len(s):
    length = 0
    for i in s:
        length = length + 1
    print(length)

my_len("hello world")

定义：def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。

　　　def 是固定的，不能变，他就是定义函数的关键字。

　　　空格 为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空多少都行，但正常人还是空1格。

　　　函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能

　　　括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！

注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。

调用：就是 函数名() 要记得加上括号。

def my_len():
    s = 'hello world'
    length = 0
    for i in s:
        length = length + 1
    return length

str_len = my_len()
print(str_len)

def maxnumber(x,y):
    the_max = x if x > y else y
    return the_max

ret = maxnumber(10,20)
print(ret)

def maxnumber(x,y):
    the_max = x if x > y else y
    return the_max

ret = maxnumber(y = 10,x = 20)
print(ret)

def maxnumber(x,y):
    the_max = x if x > y else y
    return the_max

ret = maxnumber(10,y = 20)
print(ret)

def stu_info(name,age = 18):
    print(name,age)

stu_info('picaj')
stu_info('picaj',50)

def demo(a,l = []):
    l.append(a)
    print(l)

demo('abc')
demo('123')

def demo(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))

demo('picaj',1,3,[1,3,2,2],{'a':123,'b':321},country='china',b=1)

# args 捕获所有位置参数：'picaj', 1, 3, [1, 3, 2, 2], {'a': 123, 'b': 321}，并以元组的形式返回。kwargs 捕获所有关键字参数：country='china' 和 b=1，并以字典的形式返回。因此，args 是一个元组，包含传入的所有位置参数；kwargs 是一个字典，包含传入的所有关键字参数。

def func():
    global a
    a = 3

func()
print(a)

count = 1
def search():
    global count
    count = 2

search()
print(count)

li = [1,2,3]
dic = {'name':'picaj'}

def change():
    li.append(4)
    dic['age'] = 18
    print(dic)
    print(li)

change()
print(dic)
print(li)

def add_b():
    b = 1
    def do_global():
        b = 10
        print(b)
        def dd_nolocal():
            nonlocal b  # 应用了上一层的变量b
            b = b + 20
            print(b)    # 发生了改变
        dd_nolocal()    # 调用函数，导致do_global的命名空间b也改变了
        print(b)
    do_global()
    print(b)
add_b()     # 最上面一层没有变化

def mymax(x,y):
    m = x if x > y else y
    return m

def maxx(a,b,c,d):
    res1 = mymax(a,b)
    res2 = mymax(res1,c)
    res3 = mymax(res2,d)
    return res3

ret = maxx(23,453,12,-13)
print(ret)

def f1():
    print("in f1")
    def f2():
        print("in f2")
    f2()

f1()

def func():
    name = 'picaj'
    def inner():
        print(name)
    return inner

f = func()
f()

def func():
    name = 'picaj'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()
# 最后运行的结果里面有cell就是闭包

name = 'picaj'
def func():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()
# 输出结果为None，说明不是闭包

import time

def func1():
    print('in func1')

def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

func1 = timer(func1)# 将函数本身做为参数传递进去
func1()

import time

def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner

@timer   # 等价于func1 = timer(func1)
def func1():
    time.sleep(1)
    print('in func1')

func1()

from functools import wraps

def deco(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    '''这是一条注释信息'''
    print('from index')

print(index.__doc__)    # 查看函数注释
print(index.__name__)   # 查看函数名称

def outer(func):
    def inner(*args,**kwargs):
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner

# 下面是加上wraps的固定结构
from functools import wraps

def outer(func):
    @wraps(func)
    def inner(*args,**kwargs)
        '''执行函数之前要做的'''
        re = func(*args,**kwargs)
        '''执行函数之后要做的'''
        return re
    return inner

# 字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的
from collections.abc import Iterable

l = [1, 2, 3, 4]
t = (1, 2, 3, 4)
d = {1: 2, 3: 4}
s = {1, 2, 3, 4}

print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s, Iterable))

True
True
True
True

from collections.abc import Iterator

isinstance([], Iterator)
False

isinstance(iter([]), Iterator)
True

isinstance(iter("abc"), Iterator)
True

l = [1, 2, 3, 4]

l_iter = l.__iter__()
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)
item = l_iter.__next__()
print(item)

1
2
3
4

def genrator_func1():
    a = 1
    print('将a赋值')
    yield a
    b = 2
    print('将b赋值')
    yield b

g1 = genrator_func1()

print(g1,next(g1))
print(next(g1))

将a赋值
<generator object genrator_func1 at 0x000002471D73FAC0> 1
将b赋值
2

def generator():
    print(123)
    content = yield 1
    print('欢迎来到',content)
    print(456)
    yield 2

g = generator()
ret = g.__next__()
print('***',ret)
ret = g.send('江苏')
print('***',ret)

123
*** 1
欢迎来到江苏
456
*** 2

#30以内所有能被3整除的数
multiples = [i for i in range(30) if i % 3 == 0]
print(multiples)

#30以内所有能被3整除的数的平方
def squared(x):
    return x*x

multiples = [squared(i) for i in range(30) if i % 3 == 0]
print(multiples)

#找到嵌套列表中名字含有两个及以上‘a’的所有名字
fruits = [['peach','Lemon','Pear','avocado','cantaloupe','Banana','Grape'],
          ['raisins','plum','apricot','nectarine','orange','papaya']]

print([name for lst in fruits for name in lst if name.count('a') >= 2])

[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]
['avocado', 'cantaloupe', 'Banana', 'papaya']

#将一个字典的key和value对调
dic1 = {'a':1,'b':2}

dic2 = {dic1[k]: k for k in dic1}
print(dic2)

#合并大小写对应的value值，将k统一成小写
dic1 = {'a':1,'b':2,'y':1, 'A':4,'Y':9}

dic2 = {k.lower():dic1.get(k.lower(),0) + dic1.get(k.upper(),0) for k in dic1.keys()}
print(dic2)

{1: 'a', 2: 'b'}
{'a': 5, 'b': 2, 'y': 10}

#计算列表中每个值的平方，自带去重功能
l = [1,2,3,4,1,-1,-2,3]

squared = {x**2 for x in l}
print(squared)

{16, 1, 4, 9}

ret = eval('2 + 2')
print(ret)

n = 20
ret = eval('n + 23')
print(ret)

eval('print("Hello world")')

s = '''
for i in range(5):
    print(i)
'''

exec(s)

# 流程语句使用exec
code1 = 'for i in range(5): print(i)'
compile1 = compile(code1,'','exec')

exec(compile1)

# 简单求值表达式用eval
code2 = '1 + 2 + 3'
compile2 = compile(code2,'','eval')
eval(compile2)

# 交互语句用single
code3 = 'name = input("please input you name: ")'
compile3 = compile(code3,'','single')

exec(compile3)
print(name)

print(hash(12322))

print(id('123'))

print(dir())        # 获得当前模块的属性列表
print(dir([ ]))     # 查看列表的方法

ite = reversed(['a',2,4,'f',12,6])
for i in ite:
    print(i)

l = ['a','b','c','d','e','f','g']
sli = slice(3)
print(l[sli])

sli = slice(0,7,2)
print(l[sli])

# ord 输入字符找该字符编码的位置
print(ord('a'))
print(ord('中'))

# chr 输入位置数字找出其对应的字符
print(chr(97))
print(chr(20013))

# 是ascii码中的返回该值，不是就返回/u...
print(ascii('a'))
print(ascii('中'))

print(enumerate([1,2,3]))

for i in enumerate([1,2,3]):
    print(i)

for i in enumerate([1,2,3],100):
    print(i)

<enumerate object at 0x0000015001723A80>
(0, 1)
(1, 2)
(2, 3)
(100, 1)
(101, 2)
(102, 3)

l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
    print(i)

(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))

def func(x):
    return x%2 == 0
ret = filter(func,[1,2,3,4,5,6,7,8,9,10])
print(ret)
for i in ret:
    print(i)

<filter object at 0x000002C50E380E50>
2
4
6
8
10

def square(x):
    return x**2

ret1 = map(square,[1,2,3,4,5,6,7,8])
ret2 = map(lambda x:x ** 2,[1,2,3,4,5,6,7,8])
ret3 = map(lambda x,y : x+y,[1,2,3,4,5,6,7,8],[8,7,6,5,4,3,2,1])

for i in ret1:
    print(i,end=' ')
print('')
for i in ret2:
    print(i,end=' ')
print('')
for i in ret3:
    print(i,end=' ')

1 4 9 16 25 36 49 64 
1 4 9 16 25 36 49 64 
9 9 9 9 9 9 9 9 

l=[3,2,100,999,213,1111,31121,333]
print(max(l))

dic={'k1':10,'k2':100,'k3':30}


print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

res = filter(lambda x:x>10,[5,8,11,9,15])
for i in res:
    print(i)

31121
k3
100
1
25
49
16
64
11
15

def foo(n):
    print(n)
    n += 1
    foo(n)
foo(1)

l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
def search(num,l,start=None,end=None):
    start = start if start else 0
    end = len(l)-1 if end is None else end
    mid = (end - start)//2 + start
    if start > end:
        return None
    elif l[mid] > num :
        return search(num,l,start,mid-1)
    elif l[mid] < num:
        return search(num,l,mid+1,end)
    elif l[mid] == num:
        return mid

ret = search(18,l)
print(ret)

import numpy
import sys

import numpy
numpy.array()

from numpy import *
array()

__all__ = ["array"]
#这个表示numpy如果被以from numpy import *形式调用，那么只能导入array这个函数

import json

dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)
# 序列化：将一个字典转换成一个字符串

print(type(str_dic),str_dic)
dic2 = json.loads(str_dic)
print(type(dic2),dic2)
# 反序列化：将一个字符串格式的字典转换成一个字典

list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic)
print(type(str_dic),str_dic)

list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2)

#序列化：
import json
with open('data.txt','w',encoding="utf-8") as f:
    json.dump(data,f,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
----------------结果：
{
  "age":88,
  "job":"学习",
  "name":"picaj"
}
#dump将内容序列化，并写入打开的文件中。



# 反序列化：
import json
with open('data.txt','r',encoding="utf-8") as f:
    json_data = json.load(f)
    print(json_data)
---------------结果:
<class 'dict'> {'age': 88, 'job': '学习', 'name': 'picaj'}
#从文件里读出字符串，

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)

dic2 = pickle.loads(str_dic)
print(dic2)

import time
struct_time = time.localtime(time.time())
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10,'str':'hello','float':0.123}
f.close()

f1 = shelve.open('shelve_file')
ret = f1['key']
f1.close()
print(ret)

import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())

# 如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的
import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 '.encode('utf-8'))
md5.update('in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())

#MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似
import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use md5 '.encode('utf-8'))
sha1.update('in python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())

import time

# 第一种时间格式，时间戳的形式
print(time.time())

# 第二种时间格式，格式化的时间
print(time.strftime('%Y-%m-%d %X'))
print(time.strftime('%Y-%m-%d %H-%M-%S'))

# 第三种时间格式，结构化的时间，是一个元组
print(time.localtime())

import time

# 格式化时间 ---->  结构化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S')
st = time.strptime(ft,'%Y/%m/%d %H:%M:%S')
print(st)
# 结构化时间 ---> 时间戳
t = time.mktime(st)
print(t)

# 时间戳 ----> 结构化时间
t = time.time()
st = time.localtime(t)
print(st)
# 结构化时间 ---> 格式化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S',st)
print(ft)

import time

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
print(time.asctime(time.localtime(1550312090.4021888)))

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
print(time.ctime(1550312090.4021888))

# 计算时间差
import time

start_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
end_time=time.mktime(time.strptime('2019-09-12 11:00:50','%Y-%m-%d %H:%M:%S'))
dif_time=end_time-start_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

# datatime模块
import datetime
now_time = datetime.datetime.now()  # 现在的时间
# 只能调整的字段：weeks days hours minutes seconds
print(datetime.datetime.now() + datetime.timedelta(weeks=3)) # 三周后
print(datetime.datetime.now() + datetime.timedelta(weeks=-3)) # 三周前
print(datetime.datetime.now() + datetime.timedelta(days=-3)) # 三天前
print(datetime.datetime.now() + datetime.timedelta(days=3)) # 三天后
print(datetime.datetime.now() + datetime.timedelta(hours=5)) # 5小时后
print(datetime.datetime.now() + datetime.timedelta(hours=-5)) # 5小时前
print(datetime.datetime.now() + datetime.timedelta(minutes=-15)) # 15分钟前
print(datetime.datetime.now() + datetime.timedelta(minutes=15)) # 15分钟后
print(datetime.datetime.now() + datetime.timedelta(seconds=-70)) # 70秒前
print(datetime.datetime.now() + datetime.timedelta(seconds=70)) # 70秒后

current_time = datetime.datetime.now()
# 可直接调整到指定的 年 月 日 时 分 秒 等

print(current_time.replace(year=1977))  # 直接调整到1977年
print(current_time.replace(month=1))  # 直接调整到1月份
print(current_time.replace(year=1989,month=4,day=25))  # 1989-04-25 18:49:05.898601

# 将时间戳转化成时间
print(datetime.date.fromtimestamp(1232132131))  # 2009-01-17

import random

print(random.random())          # 大于0且小于1之间的小数
print(random.uniform(1,3))      # 大于1小于3的小数

print(random.randint(1,5))      # 大于等于1且小于等于5之间的整数
print(random.randrange(1,10,2))   # 大于等于1且小于10之间的奇数

ret = random.choice([1,'23',[4,5]])     # 1或者23或者[4,5]
print(ret)

a,b = random.sample([1,'23',[4,5]],2)   # 列表元素任意2个组合
print(a,b)

item = [1,3,5,7,9]
random.shuffle(item)    # 打乱次序
print(item)

import re

print(re.findall('\w','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\W','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\s','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\S','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\d','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\D','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('\A上大','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('^上大','上大人123asdfg%^&*(_ \t \n)'))

print(re.findall('666\Z','上大人123asdfg%^&*(_ \t \n)666'))
print(re.findall('666$','上大人123asdfg%^&*(_ \t \n)666'))

print(re.findall('\n','上大人123asdfg%^&*(_ \t \n)'))
print(re.findall('\t','上大人123asdfg%^&*(_ \t \n)'))

['上', '大', '人', '1', '2', '3', 'a', 's', 'd', 'f', 'g', '_']
['%', '^', '&', '*', '(', ' ', '\t', ' ', '\n', ')']
[' ', '\t', ' ', '\n']
['上', '大', '人', '1', '2', '3', 'a', 's', 'd', 'f', 'g', '%', '^', '&', '*', '(', '_', ')']
['1', '2', '3']
['上', '大', '人', 'a', 's', 'd', 'f', 'g', '%', '^', '&', '*', '(', '_', ' ', '\t', ' ', '\n', ')']
['上大']
['上大']
['666']
['666']
['\n']
['\t']

import re

print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb'))
print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL))

print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b'))

print(re.findall('a*b', 'ab aab aaab abbb'))
print(re.findall('ab*', 'ab aab aaab abbbbb'))

print(re.findall('a+b', 'ab aab aaab abbb'))

print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb'))

print(re.findall('a.*b', 'ab aab a*()b'))

print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab'))
# .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
# 而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配 推荐使用!

# []: 括号中可以放任意一个字符,一个中括号代表一个字符
# - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
# ^ 在[]中表示取反的意思.
print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[abc]b', 'aab abb acb adb afb a_b'))
print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b'))
print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b'))
print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b'))
print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b'))
print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b'))
print(re.findall('a[^a-z]b', 'acb adb a3b a*b'))

# 分组：() 制定一个规则,将满足规则的结果匹配出来
print(re.findall('(.*?)_66', 'cs_66 zhao_66 日天_66'))
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))

print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))
# 分组() 中加入?: 表示将整体匹配出来而不只是()里面的内容

['aab', 'a*b', 'a2b', 'a牛b']
['aab', 'a*b', 'a2b', 'a牛b', 'a\nb']
['ab', 'ab', 'ab', 'b', 'ab', 'b', 'ab', 'b']
['ab', 'aab', 'aaab', 'ab', 'b', 'b']
['ab', 'a', 'ab', 'a', 'a', 'ab', 'abbbbb']
['ab', 'aab', 'aaab', 'ab']
['aab', 'aaab', 'aaaab']
['ab aab a*()b']
['ab', 'a1b', 'a*()b', 'aaaaaab']
['a1b', 'a3b', 'aeb', 'a*b', 'arb', 'a_b']
['aab', 'abb', 'acb']
['a1b', 'a3b']
['aeb', 'arb']
['aAb', 'aWb', 'aeb', 'arb']
['a11b', 'a12b', 'a34b']
['a*b', 'a+b']
['a-b', 'a*b', 'a+b']
['a3b', 'a*b']
['cs', ' zhao', ' 日天']
['http://www.baidu.com']
['ies', 'y']
['companies', 'company']

import re

# findall 全部找到返回一个列表
print(re.findall('a','aghjmnbghagjmnbafgv'))

# search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None
print(re.search('Eagle', 'welcome to Eagleslab'))
print(re.search('Eagle', 'welcome to Eagleslab').group())

# match：None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
print(re.match('niubi|picaj', 'picaj 66 66 demon 日天'))
print(re.match('picaj', 'picaj 66 66 barry 日天').group())

# split 分割 可按照任意分割符进行分割
print(re.split('[:：,;；，]','1;3,c,a：3'))

# sub 替换
print(re.sub('中国','江苏','欢迎来到中国'))

# complie 根据包含的正则表达式的字符串创建模式对象。可以实现更有效率的匹配。
obj = re.compile('\d{2}')
print(obj.search('abc123eeee').group())
print(obj.findall('1231232aasd'))

ret = re.finditer('\d','asd123affess32432')      # finditer返回一个存放匹配结果的迭代器
print(ret)
print(next(ret).group())
print(next(ret).group())
print([i.group() for i in ret])

['a', 'a', 'a']
<re.Match object; span=(11, 16), match='Eagle'>
Eagle
<re.Match object; span=(0, 8), match='picaj'>
picaj
['1', '3', 'c', 'a', '3']
欢迎来到江苏
12
['12', '31', '23']
<callable_iterator object at 0x000002705AFC3FA0>
1
2
['3', '3', '2', '4', '3', '2']

import re

ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
print(ret.group('tag_name'))
print(ret.group())

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# 如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
# 获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())

h1
<h1>hello</h1>
h1
<h1>hello</h1>

import re
from urllib.request import urlopen, Request
import os

user_agent = ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 '
              'Safari/537.36 Edg/123.0.0.0')
tmp = []
for i in range(0, 276, 25):
    url = 'https://www.douban.com/doulist/134462233/?start={}&sort=seq&playable=0&sub_type='.format(i)

    req = Request(url, headers={'User-Agent': user_agent})

    html = urlopen(req).read().decode('utf-8')
    link = re.findall(r'<div class="post">\s*<a.*?>\s*<img.*?src="(.*?)".*?</a>\s*</div>\s*<div '
                      r'class="title">\s*<a.*?>\s*<img.*?>\s*(.*?)\s*</a>\s*</div>', html, re.DOTALL)
    tmp.extend(link)
path = os.path.join(os.getcwd(), 'movie')
if not os.path.exists(path):
    os.mkdir(path)
print('电影将为你保存在{}路径下'.format(path))

for i in tmp:
    movie_url = i[0]
    movie_name = i[1]

    # 在文件名中包含文件夹路径
    file_path = os.path.join(path, '{}.jpg'.format(movie_name))

    req = Request(movie_url, headers={'User-Agent': user_agent})
    data = urlopen(req).read()

    # 将照片保存在指定文件夹下
    with open(file_path, 'wb') as f:
        f.write(data)
    print("{} 已经下载好了".format(movie_name))

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = picaj

[topsecret.server.com]
Port = 50022
ForwardX11 = no

import configparser

conf = configparser.ConfigParser()

conf['DEFAULT'] = {'ServerAliveInterval':'45',
                   'Compression':'yes',
                   'CompressionLevel':'9',
                   'ForwardX11':'yes'
                   }
conf['bitbucket.org'] = {'User':'picaj'}
conf['topsecret.server.com'] = {'Port':'50022',
                                'ForwardX11':'no'
                                }

with open('config','w') as config:
    conf.write(config)

import configparser

conf = configparser.ConfigParser()

conf['DEFAULT'] = {'ServerAliveInterval':'45',
                   'Compression':'yes',
                   'CompressionLevel':'9',
                   'ForwardX11':'yes'
                   }
conf['bitbucket.org'] = {'User':'picaj'}
conf['topsecret.server.com'] = {'Port':'50022',
                                'ForwardX11':'no'
                                }

print('bitbucket.org' in conf)
print('bitbucket.com' in conf)

print(conf['bitbucket.org']['user'])
print(conf['DEFAULT']['Compression'])
# DEFAULT的键也会出现

for key in conf['bitbucket.org']:
    print(key)  
# 同for循环,找到'bitbucket.org'下所有键

print(conf.options('bitbucket.org'))
# 找到'bitbucket.org'下所有键值对

print(conf.items('bitbucket.org'))

print(conf.get('bitbucket.org','compression'))

import configparser

conf = configparser.ConfigParser()

conf.read('config')

conf.add_section('picaj')    # 添加键

conf.remove_section('bitbucket.org')    # 删除键
conf.remove_option('topsecret.server.com','forwardx11') # 移除条目

conf.set('topsecret.server.com','k1','11111')   # 在对应键下加上条目
conf.set('picaj','k2','22222')

conf.write(open('config.new','w'))  # 写入文件

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

import logging

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S',
                    filename='test.log',
                    filemode='w')

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

import logging

logger = logging.getLogger()

# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') 
# 再创建一个handler，用于输出到控制台 
ch = logging.StreamHandler() 

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

fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter) 

ch.setFormatter(formatter) 


logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 
logger.addHandler(ch) 
logger.debug('logger debug message') 
logger.info('logger info message') 
logger.warning('logger warning message') 
logger.error('logger error message') 
logger.critical('logger critical message')

"""
logging配置
"""

import os
import logging.config

# 定义三种日志输出格式 开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'a.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

注意：


#1、有了上述方式我们的好处是：所有与logging模块有关的配置都写到字典中就可以了，更加清晰，方便管理


#2、我们需要解决的问题是：
    1、从字典加载配置：logging.config.dictConfig(settings.LOGGING_DIC)

    2、拿到logger对象来产生日志
    logger对象都是配置到字典的loggers 键对应的子字典中的
    按照我们对logging模块的理解，要想获取某个东西都是通过名字，也就是key来获取的
    于是我们要获取不同的logger对象就是
    logger=logging.getLogger('loggers子字典的key名')


    但问题是：如果我们想要不同logger名的logger对象都共用一段配置，那么肯定不能在loggers子字典中定义n个key   
 'loggers': {    
        'l1': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
        'l2: {
            'handlers': ['default', 'console' ], 
            'level': 'DEBUG',
            'propagate': False,  # 向上（更高level的logger）传递
        },
        'l3': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },

}


#我们的解决方式是，定义一个空的key
    'loggers': {
        '': {
            'handlers': ['default', 'console'], 
            'level': 'DEBUG',
            'propagate': True, 
        },

}

这样我们再取logger对象时
logging.getLogger(__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去loggers里找key名时却发现找不到，于是默认使用key=''的配置

from collections import namedtuple
point = namedtuple('point',['x','y'])
p = point(1,2)
print(p.x)

from collections import deque

q = deque(['a','b','c'])
q.append('x')
q.appendleft('y')

print(q)

from collections import OrderedDict

d = dict([('a',1),('b',2),('c',3)])
print(d)

od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)

# 以前的做法
li = [11,22,33,44,55,77,88,99,90]

result = {}
for row in li:
    if row < 66:
        if 'key1' not in result:
            result['key1']=[]
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2']=[]
        result['key2'].append(row)
print(result)
#defaultdict
from collections import defaultdict

li = [11,22,33,44,55,77,88,99,90]
result=defaultdict(list)

for row in li:
    if row > 66:
        result['key1'].append(row)
    else:
        result['key2'].append(row)

print(result)

from collections import Counter

c = Counter('qazxswqazxswqazxswsxaqwsxaqws') 
print(c)

import shutil

shutil.copyfileobj(open('config','r'),open('config.new','w'))

import shutil

shutil.copyfile('config','config1') # 目标文件无需存在

import shutil

shutil.copymode('config','config1') # 目标文件必须存在

import shutil

shutil.copystat('config','config1') # 目标文件必须存在

import shutil

shutil.copy('config','config1') # 目标文件必须存在

import shutil

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
# 目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
# 硬链接

shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
# 软链接

import shutil

shutil.rmtree('folder1')

import shutil

shutil.move('folder1', 'folder3')

# 将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')


# 将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

import zipfile

# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()
import tarfile

# 压缩文件
t = tarfile.open('/tmp/egon.tar','w')
t.add('/test1/a.py',arcname='a.bak')
t.add('/test1/b.py',arcname='b.bak')
t.close()

# 解压缩文件
t = tarfile.open('/tmp/egon.tar','r')
t.extractall('/egon')
t.close()

#语法错误示范一
if

#语法错误示范二
def test:
    pass

#语法错误示范三
print(haha

#用户输入不完整(比如输入为空)或者输入非法(输入不是数字)
num=input(">>: ")
res1 = int(num)

#无法完成计算
res1=1/0
res2=1+'str'

# 触发IndexError
l=['eagle','aa']
l[3]
# 触发KeyError
dic={'name':'eagle'}
dic['age']

#触发ValueError
s='hello'
int(s)

# 其他异常
ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

num1=input('>>: ') #输入一个字符串试试
if num1.isdigit():
    int(num1) #我们的正统程序放到了这里,其余的都属于异常处理范畴
elif num1.isspace():
    print('输入的是空格,就执行我这里的逻辑')
elif len(num1) == 0:
    print('输入的是空,就执行我这里的逻辑')
else:
    print('其他情情况,执行我这里的逻辑')

'''
问题一：
使用if的方式我们只为第一段代码加上了异常处理，但这些if，跟你的代码逻辑并无关系，这样你的代码会因为可读性差而不容易被看懂

问题二：
这只是我们代码中的一个小逻辑，如果类似的逻辑多，那么每一次都需要判断这些内容，就会倒置我们的代码特别冗长。
'''

try:
    num = input("<<:")
    int(num)
except:
    print('你输入的是非数字')

finally:
    print('程序结束')

try:
     被检测的代码块
except 异常类型：
     try中一旦检测到异常，就执行这个位置的逻辑

s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print(e)

s1 = '10'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
except Exception as e:
   print(e)
else:
    print('try内代码块没有异常则执行我')
finally:
    print('无论异常与否,都会执行该模块,通常是进行清理工作')

try:
    raise TypeError('类型错误')
except Exception as e:
    print(e)

class EvaException(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

try:
    raise EvaException('类型错误')
except EvaException as e:
    print(e)

assert 1 == 1
assert 1 == 2

#define PyObject_HEAD       PyObject ob_base ;
#define PyObject_VAR_HEAD       PyVarObject ob_base;

//宏定义，包含上一个、下一个，用于构造双向链表用。(放到refchain链表中时，要用到)
#define _PyObject_HEAD_EXTRA            \
    struct _object *_ob_next;           \
    struct _object *_ob_prev;

typedef struct _object {
    _PyObject_HEAD_EXTRA            //用于构造双向链表
    Py_ssize_t ob_refcnt;           //引用计数器
    struct _typeobject *ob_type;    //数据类型
} PyObject;

typedef struct {
    PyObject ob_base;       // PyObject对象
    Py_ssize_t ob_size; /* Number of items in variable part, 即:元素个数*/
} PyVarObject;

a=14  # 对象被创建  
b=a   # 对象被引用 
func(a)   # 对象被作为参数,传到函数中
List=[a,"a","b",2]   # 对象作为一个元素，存储在容器中   
b = 9999 # 引用计数器的值为1
c = b  # 引用计数器的值为2

当该对象的别名被显式销毁时        del a
当该对象的引别名被赋予新的对象，   a=26
一个对象离开它的作用域，例如 func函数执行完毕时，函数里面的局部变量的引用计数器就会减一（但是全局变量不会）
将该元素从容器中删除时，或者容器被销毁时。
a = 999
b = a  # 当前计数器为2
del b # 删除变量b：b对应的对象的引用计数器-1   （此时计数器为1）
del a # 删除变量a：a对应的对象的引用计数器-1    (此时引用计数器为0)

当引用计数器为0 时，意味着没有人再使用这个对象，这个对象就变成垃圾，垃圾回收。
回收：1.对象从refchain的链表移除。
       2.将对象进行销毁，内存归还给操作系统，可用内存就增加。

v1 = [1,2,3]        # refchain中创建一个列表对象，由于v1=对象，所以列表引对象用计数器为1.
v2 = [4,5,6]        # refchain中再创建一个列表对象，因v2=对象，所以列表对象引用计数器为1.
v1.append(v2)        # 把v2追加到v1中，则v2对应的[4,5,6]对象的引用计数器加1，最终为2.
v2.append(v1)        # 把v1追加到v1中，则v1对应的[1,2,3]对象的引用计数器加1，最终为2.

del v1    # 引用计数器-1
del v2    # 引用计数器-1

最终v1,v2引用计数器都是1

v1 = 3.14  # 创建float型对象，加入refchain，并且引用计数器的值为1
del v1   #refchain中移除，按理说应该销毁，但是python会将对象添加到free_list中。

v2 = 9.999  # 就不会重新开辟内存，去free_list中获取对象，对象内部数据初始化，再放到refchain中。