Python基本语法&结构

函数

定义

def function_name(parameter = "default_value"):

pass // 使用pass定义空函数

return a, b, c //返回多个参数时, 多个参数放在同一个元组(tuple)中

参数

位置参数

• 参数传入时, 实参与形参位置一一对应

默认参数

• 设置默认参数大坑: 默认参数必须为不变对象

//借助None、string等不变对象为可变对象设置默认值

def add_end(L=None):

    if L is None:

        L = []

    L.append('END')

    return L

可变参数

// 传入一串参数, 函数接收时以tuple形式存储

def calc(*numbers):

        sum = 0

    for n in numbers:

        sum = sum + n * n

    return sum

-----------snip-------------

>>> calc(1, 2)

5

>>> calc()

0

• 若已经存在list或tuple, 可在前添加*作为参数传入函数

map

• map(fuction_name, iterable)

• 将接收的函数依次作用于每个元素, 返回一个iterator

def standardize_name(name):

    return name.lower().capitalize()

# 使用map

r = map(standardize_name, ['adam', 'LISA', 'barT'])

# map 返回一个 iterator, 可使用next(r)访问元素

print(list(r))

reduce

• reduce(function_of_two_vars, iterable)

• 函数必须为二元函数

• 传两个参数, 通过函数计算出结果, 将该结果作为下次传入函数的参数之一, 累积运算

from functools import reduce

def add(x, y):

return x + y

----------------snip-------------------

reduce(add, [1, 3, 5, 7, 9])

snip------------------

25 //输出结果

filter

• filter(function_name, iterable)

• 作用于传入的每个函数, 根据返回值的真假, 决定元素的去留, 并返回一个iterator

sorted

• 运用sorted+ lambda实现简洁排序

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)// key可传入lambda 形式函数

['Zoo', 'Credit', 'bob', 'about']

补充-匿名函数lambda

• 传入参数 : 执行表达式

lambda x, y: x*y

# 函数输入x, y 输出两者积

返回函数

闭包 closure

Python闭包详解

Python小记

• 闭包函数必须返回一个函数对象,

• 返回的函数必须引用外部变量(非全局变量), 返回函数可以无return

def line_conf(a, b):

def line(x):

        return a * x + b # 引用外部变量a,b

    return line # 返回函数line

---------------snip------------------

 #定义两条直线

line_A = line_conf(2, 1) #y=2x+b

line_B = line_conf(3, 2) #y=3x+2



#打印x对应y的值

print(line_A(1)) #3

print(line_B(1)) #5

• 命名闭包: 每次对闭包外函数的调用, 都会创建新的闭包, 使用不同的变量名来区分闭包

f1, f2, f3 = ExFunc() # 命名闭包

f1() # 执行闭包

• 闭包中引用循环变量: 将循环变量绑定至默参数

def fo():

    fs = []

    for i in range(3):

        def foo(x, y=i): # 循环变量设置为y的默认值

            return x+y

        fs.append(foo)

    return fs

f1, f2, f3 = fo()

print(f1(1), f2(1), f3(1))

闭包优点&实际应用

• 销毁机制: 普通函数无法保存运行环境

• 闭包保存运行环境: 通过调用外部变量, 保存运行环境, 具体机制不明

待补充

装饰器 decorator

Python小记

刘志军-装饰器讲解

• 函数也是Python中的对象

• 装饰器为已经存在的对象添加额外功能

def decorator_name(fuc):

    def wrapper(*args, **kwargs): # 用于接收被装饰函数参数

        statement

        return fuc(*args, **kwargs)

    return warpper

@decorator_name # 表明接下来的函数使用装饰器

def fuc(vara, varb):

    statement



fuc()

• 带参数的装饰器

import logging

def use_logging(level):

    def decorator(func):

        def wrapper(*args):

            print(level)  # 引用外部变量 level(非全局)

            logging.warning("%s is running" % func.__name__)  # 引用全局变量func

            return func(*args)  # 返回被修饰函数结果

        return wrapper

    return decorator

@use_logging('nice')  # 相当于 BAR = use_logging('nice')\n BAR(bar(1, 2))

def bar(x, y):

    print('i am bar', x, y)

bar(1, 2)

-----------------snip---------------------

# 结果

nice

WARNING:root:bar is running

i am bar 1 2

-----------------snip---------------------

疑问: 根据之前了解到的闭包定义, 此处返回的函数对象 decorator 应当引用外部变量, 但是此处是 其内部的wrapper 引用了外部变量

装饰器优点&实际应用

待补充

装饰器内容补充

流畅的python-第七章 函数装饰器和闭包

模块

基本定义

• 模块 module: 将函数进行分类, 放入至多个.py文件中, 一个.py文件称之为模块

• **包 **package: 为避免模块命名冲突, python引用目录来组织模块

  • __init__.py: package下必须添加该文件, 否则Python会将其识别为普通界面

待补充

其他

偏函数

• 固定一个函数的常用参数,

import functools

int2 = functools.partial(int, base=2)  # 固定int()函数的进制参数为 2

int2('1000000')

64 # 结果

# 非偏函数实现

def int2(x, base=2):

    return int(x, base)

面向对象编程

菜鸟教程-Python面向对象 -待补充http://www.runoob.com/python/python-object.html

面向对象编程

[图片上传失败...(image-b5f148-1570431464292)]

• 类 class: 自定义对象

• 方法 method: 调用对象关联的函数

• 实例 instance: 传入参数后的对象

class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.score = score

    def print_score(self):

        print('%s: %s' % (self.name, self.score))

私有变量: 限制访问内部属性

• 私有变量: 通过添加__至变量前, Python将__name识别为_Student__name, 即添加了一道转化过程[^ 1], 防止name变量被直接修改

class Student(object):

    def __init__(self, name, score):

        self.__name = name  # 添加"__"设置为私有变量

        self.__score = score

特殊变量

待补充

获取&修改私有变量

待补充

继承: 获取其他类的全部属性

• 方法重写: 在子类中重新定义父类方法, 子类方法将会覆盖父类方法

• 多态: 定义Class, 相当于定义了一种数据类型, 继承父类方法后, 该子类则具备了两种数据类型的属性

Class SubClassName (ClassName):

def __init__(self, var1, var2, var3):

        '''初始化父类属性'''

        super().__init__(var1, var2, var3)

待补充

获取对象信息

• type()判断对象类型

>>> type(123)

<class 'int'>

• types()判断对象是否是函数

>>> import types

>>> def fn():

...    pass

...

>>> type(fn)==types.FunctionType

True

• isinstance(对象名, 类名)判断属于何种class类型

>>> a = Animal()

>>> d = Dog()

>>> h = Husky()

>>> isinstance(h, Husky)

True

• dir()获取对象的所有属性和方法

>>> dir('ABC')

['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']

# 返回一个字符串, 包含所有属性和方法

实例属性&类属性

• 创建实例&类属性

# 通过定义同名类属性和实例属性, 来比较两种属性的优先级, 实例优先于类属性

class Student(object):

    name = 'Student'  # 创建类属性

    def __init__(self, name):

        self.name = name  # 创建实例属性

print(Student.name)

Student = Student('Mike')

Student.name = 'Killy'  # 绑定新属性

print(Student.name)

# 打印结果

Student

Killy

限制实例的属性

面向对象高级编程

多重继承

• 一个子类获取多个父类的方法和属性

Mixin

Python中的Mixin类 : Python多继承的魔力

待补充

定制类

待补充, 定义特殊方法, 使类能够进行 遍历 切片

枚举类

待补充

使用元类

待补充(基本用不到)

处理错误

单个程序是否出错

检测修改后程序功能是否完整

文档测试

待补充

IO编程

基本定义

• IO : input 发送数据, output 接收数据

• 异步IO性能高于同步IO

储存数据

将代码生成或者处理完成的数据转化为JSON进行储存

• JSON形式写入数据&读取

#!/usr/bin/env python3

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

import json

d = dict(name='Bob', age=20, score=88)

data = json.dumps(d)

print('JSON Data is a str:', data)

reborn = json.loads(data)

print(reborn)

# 定义测试类

class Student(object):

    def __init__(self, name, age, score):

        self.name = name

        self.age = age

        self.score = score

    def __str__(self):

        return 'Student object (%s, %s, %s)' % (self.name, self.age, self.score)

s = Student('Bob', 20, 88)

std_data = json.dumps(s, default=lambda obj: obj.__dict__)

print('Dump Student:', std_data)

rebuild = json.loads(std_data, object_hook=lambda d: Student(d['name'], d['age'], d['score']))

print(rebuild)

-------------------sinp----------------------

JSON Data is a str: {"name": "Bob", "age": 20, "score": 88}

{'name': 'Bob', 'age': 20, 'score': 88}

Dump Student: {"name": "Bob", "age": 20, "score": 88}

Student object (Bob, 20, 88)

进程和线程

搞定python多进程和多线程

深入理解python中的ThreadLocal变量(上) 待补充

基本概念

• 进程 process : 主任务

• 线程 thread : 主任务下的子任务

• 多任务: 操作系统通过极速交替执行多个任务, 使得任务看起来像同时进行

情境举例

打开word: 启动word进程, 主任务

在word中打字(子任务1), 排版(子任务2)

• 多任务实现的三种模式

  • 多进程模式

  • 多线程模式

  • 多进程+多线程模式

• 多进程和多线程区别

  • 多进程 : 同一变量, 每个进程中都有一份该进程的拷贝, 修改互不影响

  • 多线程 : 所有线程共享同一个变量, 需要使用Lock防止变量被改乱

在windows上编写多进程程序

• multiprocessing模块提供Process类

from multiprocessing import Process

import os

# 子进程要执行的代码

def run_proc(name):

    print('Run child process %s (%s)...' % (name, os.getpid()))

# os.getpid()获取父进程ID

if __name__=='__main__':

    print('Parent process %s.' % os.getpid())

    '''创建Process实例, 传入执行函数, 函数参数, 使用 star()启动, join() 用于等待进程结束后继续运行'''

    p = Process(target=run_proc, args=('test',))

    print('Child process will start.')

    p.start()

    p.join()

    print('Child process end.')

待补充

多线程

• _thread和threading(常用)提供Thread类

import time, threading

# 传入Thread中的函数

def loop():

    print('thread %s is running...' % threading.current_thread().name)

    n = 0

    while n < 5:

        n = n + 1

        print('thread %s >>> %s' % (threading.current_thread().name, n))

        time.sleep(1)

    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)

'''创建Thread实例, 传入执行函数, 设置线程名字为LoopThread'''

t = threading.Thread(target=loop, name='LoopThread')

t.start()

t.join()

print('thread %s ended.' % threading.current_thread().name)

Lock

• 无论有多少线程, 同一时刻只有一个进程拥有锁, 避免了修改造成的冲突

• threading.lock()创建锁

balance = 0

# 创建锁

lock = threading.Lock()

def change_it(n):

    global balance

    balance = balance + n

    balance = balance - n



def run_thread(n):

    for i in range(100000):

        # 获取锁

        lock.acquire()

        try:

            change_it(n)

        finally:

        # 释放锁,否则其他进程无法执行change_it()

            lock.release()

TreadLocal

解决python中各线程之间局部变量的传递问题

待补充

分布式进程

将多进程分布至多台机器上使用

待补充

常用内建模块

datetime

• 获取时间, 在datetime 和 timetamp间相互转换

• 时区转换, 待补充

collections

namedtuple

'''创建一个自定义元素个数的tuple, 并可以通过属性来访问'''

from collections import namedtuple

Point = namedtuple('test', ['x', 'y'])

p = Point(1, 2)

print(p.x)

deque

添加了popleft以及appendleft

defaultdict

python中 defaultdict用法详解

https://www.jianshu.com/p/bbd258f99fd3

python中 defaultdict与lambda表达式配合使用

from collections import defaultdict

dict1 = defaultdict(int) # 默认输出0

dict2 = defaultdict(set) # 默认输出set()

dict3 = defaultdict(str) # 默认输出空字符串

dict4 = defaultdict(list) # 默认输出[]

dict5 = defaultdict(lambda: 'N/A')

dict1[2] ='two'

print(dict1[1])

print(dict2[1])

print(dict3[1])

print(dict4[1])

print(dict5[1])

-------------------snip--------------------

输出结果

0

set()

[]

N/A

OrderedDict

'''间key按照插入顺序进行排序,可以创建一个先进先出,限制容量的dict'''

from collections import OrderedDict

class LastUpdatedOrderedDict(OrderedDict):

    def __init__(self, capacity):

        super(LastUpdatedOrderedDict, self).__init__()

        self._capacity = capacity

    def __setitem__(self, key, value):

        containsKey = 1 if key in self else 0

        if len(self) - containsKey >= self._capacity:

            last = self.popitem(last=False)

            print('remove:', last)

        if containsKey:

            del self[key]

            print('set:', (key, value))

        else:

            print('add:', (key, value))

        OrderedDict.__setitem__(self, key, value)

待补充

ChainMap

不懂, 待补充

Counter

Python标准库——collections模块的Counter类

'''dict的子类, 用于统计字符的出现次数'''

from collection import Counter

print(Counter('programing'))

-------------------snip----------------------

输出结果

Counter({'r': 2, 'g': 2, 'p': 1, 'o': 1, 'a': 1, 'm': 1, 'i': 1, 'n': 1})

contextlib

python魔法版块之contextlib(附应用实例)

Python学习笔记-with语句与上下文管理器-MR怪蜀黎

• 操作文件时使用with上下文管理器

'''通过with....as语句, python将打开的文件属性绑定至file_obj上,借此进行操作; windows文件路径中使用需使用双斜杠'''

with open('C:\\Users\\HenryHe', 'r') as file_obj:

print(file_obj.read())

• with下缩进代码执行完毕后, 自动关闭文件的原理

class OpenContext(object):

    def __init__(self, filename, mode):

        '''将打开的文件绑定至fp'''

        self.fp = open(filename, mode)

    def __enter__(self):

        '''获取fp'''

        return self.fp

    def __exit__(self, exc_type, exc_val, exc_tb):

        '''文档操作结束后, 自动调用关闭'''

        self.fp.close()

with OpenContext('测试文档.txt', 'r') as file_obj:

    print(file_obj.read())

• 使用@contextmanager和yield

• with先执行yield之前的语句, 执行with下的语句, 最后执行yield之后的语句

@contextmanager

def tag(name):

    print("<%s>" % name)

    yield

    print("</%s>" % name)

with tag("h1"):

    print("hello")

    print("world")

• 使用closing将具有close()方法的任意对像, 变为上下文对象

from contextlib import closing

from urllib.request import urlopen

with closing(urlopen('https://www.python.org')) as page:

    for line in page:

        print(line)



--------------------snip--------------------

# closing 是一个经过@contextmanager装饰的generator

@contextmanager

def closing(thing):

    try:

        yield thing

    finally:

        thing.close()

• threading.lock中使用with

# 使用with

import threading

with lock:

    my_list.append(item)



------------------snip---------------------

# 不使用with

import threading

lock = threading.Lock()

lock.acquire()

try:

    my_list.append(item)

finally:

    lock.release()

urllib

urllib提供了一系列用于操作URL的功能

待补充

XML

解析XML

from xml.parsers.expat import ParserCreate

#利用SAX解析XML文档牵涉到两个部分: 解析器和事件处理器

#解析器负责读取XML文档，并向事件处理器发送事件，如元素开始跟元素结束事件。

#而事件处理器则负责对事件作出响应，对传递的XML数据进行处理

class DefualtSaxHandler(object):

    def start_element(self,name,attrs):

        print('sax:start_elment: %s,attrs: %s'%(name,str(attrs)))

        #name表示节点名称，attrs表示节点属性（字典）

    def end_element(self,name):

        print('sax:end_element: %s'%name)

    def char_data(self,text):

        print('sax:char_data: %s'%text)

        #text表示节点数据

xml=r'''<?xml version="1.0"?>

<ol>

    <li><a href="/python">Python</a></li>

    <li><a href="/ruby">Ruby</a></li>

</ol>

'''

#处理器实例

handler=DefualtSaxHandler()

#解析器实例

parser=ParserCreate()

#下面3为解析器设置自定义的回调函数

#回调函数的概念，请搜索知乎，见1.9K赞的答案

parser.StartElementHandler=handler.start_element

parser.EndElementHandler=handler.end_element

parser.CharacterDataHandler=handler.char_data

#开始解析XML

parser.Parse(xml)

#然后就是等待expat解析，

#一旦expat解析器遇到xml的 元素开始，元素结束，元素值 事件时

#会回分别调用start_element, end_element, char_data函数

#关于XMLParser Objects的方法介绍下

#详见python文档：xml.parsers.expat

#xmlparser.StartElementHandler(name, attributes)

#遇到XML开始标签时调用，name是标签的名字，attrs是标签的属性值字典

#xmlparser.EndElementHandler(name)

#遇到XML结束标签时调用。

#xmlparser.CharacterDataHandler(data)

#调用时机：

#从行开始，遇到标签之前，存在字符，content 的值为这些字符串。

#从一个标签，遇到下一个标签之前， 存在字符，content 的值为这些字符串。

#从一个标签，遇到行结束符之前，存在字符，content 的值为这些字符串。

#标签可以是开始标签，也可以是结束标签。

#为了方便理解，我已经在下面还原来解析过程，

#标出何时调用，分别用S：表示开始；E：表示结束；D：表示data

如果看不明白，请配合脚本输出结果一起看

S<ol>C

C  S<li>S<a href="/python">CPython</a>E</li>EC

C  S<li>S<a href="/ruby">CRuby</a>E</li>EC

S</ol>E

待补充

HTMLParser

python爬虫系列-beautifulsoup

解析HMTL

待补充

第三方模块

pillow

python image library

图像操作

requests

获取URL资源

chardet

检测未知编码类型

psutil

系统监控, 获取系统信息

virtualenv

创建隔离的python运行环境

图形界面

待补充

网络编程

记录了纸质笔记

待补充

访问数据库

待补充

Web开发

本章需结合图解HTTP内容

WSGI接口

WSGI: Web Server Gateway Interface 服务器网关接口

• 定义WSGI接口响应HTTP请求: 定义一个函数, 接收两个参数environ, start_response

• environ: 一个dict, 包含HTTP请求报文所有信息

• start_response: 发送HTTP响应报文的函数

# hello.py

# 定义一个WSGI接口

def application(environ, start_response):

    start_response('200 ok', [('Content-Type', 'text/html')])

    return [b'<h1>Hello, web!</n>']

# server.py

# 使用python内置模块创建测试服务器

# 命令行下运行server.py

from wsgiref.simple_server import make_server

from another_exp import application

httpd = make_server('', 8000, application)

print('正在端口8000运行HTML协议')

httpd.serve_forever()

Flask: 处理多个HTTP请求

# 处理三个URL 1.GET/: 首页, 返回Home.

# 2.GET/signin: 登录页, 显示登录表单

# 3.POST/signin: 处理登表单, 显示登录结果

from flask import Flask

from flask import request

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])

def home():

    return '<h1>Home</h1>'

@app.route('/signin', methods=['GET'])

def signin_form():

    return '''<form action="/signin" method="post">

              <p><input name="username"></p>

              <p><input name="password" type="password"></p>

              <p><button type="submit">Sign In</button></p>

              </form>'''

@app.route('/signin', methods=['POST'])

def signin():

    # 需要从request对象读取表单内容：

    if request.form['username']=='admin' and request.form['password']=='password':

        return '<h3>Hello, admin!</h3>'

    return '<h3>Bad username or password.</h3>'

if __name__ == '__main__':

    app.run()

使用模板: 将python代码与HTML代码隔离

flask模板

待补充

Django模板

待补充 主攻

异步IO

协程 Coroutine

• yield接收调用方值, 将结返回给调用方, 并暂停协程

def averager():

    total = 0.0

    count = 0

    average = None

    while True:

        term = yield average  # send发送的数据传至yeild, term接收, 同时将函数尾, 即计算后yield的值返回给c.send()

        print('yield处的average', average)

        total += term

        count += 1

        average = total/count

        print('函数尾的average', average)

c = averager()  # 创建协程对象

next(c)  # 激活生成器, 也可以使用 c.send(None)

print('返回值', c.send(10)) 

print('返回值', c.send(30))

print('返回值', c.send(5))

-----------------snip---------------------

运行结果

yield处的average 0

函数尾的average 10.0

返回值 10.0

yield处的average 10.0

函数尾的average 20.0

返回值 20.0

yield处的average 20.0

函数尾的average 15.0

返回值 15.0

• 启动协程的装饰器

from coroutil import coroutine

@coroutine

def coroutine_function():

    pass

Python对象

List

特点: 可变, 有序

• 计算元素

  • 列表长度: len(list_name)

  • 特定元素: count(value)

• 查询&获取元素

  • 返回第一个下标: index(element)

  • 下标获取

• 添加元素

  • 指定位置: insert()

  • 列表末尾: append()

  • 整个列表至末尾: extend()

• 移除元素

  • 特定元素: remove(index)

  • 特定元素: del(number)

  • 末尾元素并返回: pop()

  • 所有元素: clear()

• 复制列表

  • 整个列表: copy()

  • 使用切片复制列表list_name[:]

• 调整列表

  • 反转列表: reverse()

  • 排序列表: sort()

Tuple

特点: 有序, 不可变

• count()

• index()

Set

特点: 无序, 无重复元素, 无下标索引, 相当于一组无value、不重复的key

参考链接- https://www.w3schools.com/python/python_sets.asp

Dicthontary

特点: 无序, 可变, 有索引, 无重复键

• 获取元素

  • 获取键值对:

    • for var in dic.items()获取(key, value)

    • for var1, var2 in dic.items()获取key value

  • 遍历键: keys()

  • 遍历值: values()

  • 获取值:

    • 键名访问

    • setdefault(key, default_value)键值存在返回值, 不存在创建新键值

• 添加元素: dic[new_key] = new_value

• 删除元素

  • 特定元素并返回该元素: pop()

  • 最后添加的元素并返回该元素: popitem()

  • 特定元素: del特定元素

附录A-关于Python的学习思路

主要参考资料

廖雪峰-Python3.X教程

Python从入门到实践

Python自动化编程上手

Python数据分析

时间: 19年2月8日22点07分

• 考研期间一直使用OneNote记笔记, 当时知识点提炼概括的能力很弱, 总是一大版一大版的往上写, 现在看着都头疼, 现在开始用Typora记笔记, 主要格式为:

  • 笔记部分按教程或者章节目录划分, 写在正文

  • 启发、问题、延伸阅读资料收录入附录, 并附带:

    1. 问题的简要描述

    2. 问题产生的时间

    3. 问题是否解决

• 今天刚开始尝试这种记录方法, 之前Python笔记未进行记录, 计划总结形式为:

  • 基本语法

  • 总结典型的Python程序

    • [图片上传失败...(image-2530dd-1570431464292)]

  • 对象

    • 初步以对对象的操作来分类方法

• Python从入门到实践目前学习到了利用Python中的pygame模块, 制作简单射击游戏, 其中的指导意义大于应用意义, 主要是从游戏多模块搭建、导入、引用的过程中, 进一步理解程序功能模块化设计概念, 理解就ok

附录B-Python问题合辑

nonlocal 使用外层变量

def create_counter():

    x = 0

    print('外')

    def counter():

        nonlocal x  # 不使用时提示: UnboundLocalError: local variable 'x' referenced before assignment

        x += 1

        print('内')

        return x

    return counter

字符串操作方法.split无法处理多行字符串

# 传入主标题和多个副标题, 其中副标题以换行符进行分隔, 输出"主标题-副标题"至当前目录下txt文件

# 传入一次完成后提示重新传入

# 传输结束后, 将所有记录的内容粘贴至剪切板, 输出提示"粘贴成功"

import pyperclip

def joint_title(main_title, sub):

    sub.split('\n')

    for s in sub:

        with open(file_name, 'a') as obj_filen

            obj_file.write(main_title+'-'+s+'\n')

def output_info():

    with open(file_name) as obj_file:

        content = obj_file.read()

        pyperclip.copy(content)

    print('粘贴成功')

def wipe_file():

    with open(file_name, 'w') as obj_file:

        obj_file.write('')

        print('当前记录文档为空')

file_name = 'add_title_to_subtitle.txt'

while True:

    print('please enter your title: '+'\n'+'or enter a blank to exit'+'\n'+"or enter w to wipe the file")

    title = input()

    if title == ' ':

        output_info()

        break

    elif title == 'w':

        wipe_file()

        continue

    else:

        print('please enter your su btitle: ')

        subtitle = input()

        joint_title(title, subtitle)

        continue

状态: 未解决

if __name__ =='__main__'作用解析

浅析python中 if __name___ = ‘__mian__’的作用

https://www.cnblogs.com/alan-babyblog/p/5147770.html

python中__name__的使用

https://www.cnblogs.com/1204guo/p/7966461.html

• 该语句常用于在文件中添加测试代码, 并且保证被其他文件引用时, 测试代码只会在当前文件下运行

• __name__为python中内置的系统变量

• python中具有导入模块操作, 可以用if __name__ =='__main__' 判断是否在当前模块

• 一个.py文件相当于一个模块

# 创建文件 example.py 定义函数 test()

def test():

  print('we are in %s' % __name__)

if __name__ == '__main__':

    test()

    print('on running')

--------------------snip---------------------

运行结果

we are in __main__

on running

处于当前模块时 __name__的值为 __main__

# 同目录下创建文件 another_exp.py 文件

# 导入example.py 文件中的 test()函数

from example import test

test()

--------------------snip---------------------

运行结果

we are in example

未打印'on running', if 之后的语句没有运行

处于其他模块时 __name__的值为 原模块名字

状态: 解决

多线程改乱变量内容的原因

多线程-廖雪峰

namedtuple创建自定义tuple参数

第一个参数有什么用?

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p = Point(1, 2)

print(p.x)

状态 : 未解决

defaultdict传入什么参数

'''传入一种数据类型或者函数, 可以传入lambda创建的简单函数'''

from collections import defaultdict

dict1 = defaultdict(int)

dict2 = defaultdict(set)

dict3 = defaultdict(str)

dict4 = defaultdict(list)

dict5 = defaultdict(lambda:'ok') # 无键时默认输出ok

函数生成器捕获错误获取返回值

stackoverflow

• as将异常绑定至一个变量

def fib(number):

    n, a, b = 0, 0, 1

    while n < number:

        yield b 

        a, b = b, a + b

        n = n + 1

    return 'done'

'''由于next()运行机制, 使用for...in获取fib(6)中的元素时, 无法获取返回值, 通过捕获StopIteration来获取返回值'''

g = fib(6)

while True:

    try:

        x = next(g)

        print(x)

    except StopIteration as e:  # 捕获异常并绑定至e, 使用e.value引用返回值

        print('generator return value:', e.value)

        break

猜测: StopIteration是一个错误实, 其中的value方法储存了return的值

状态 : 未解决

from . import xxx是什么意思

相对路径导入

附录C-书本外Python编程合辑

利用mysql和flask设计简单网页

廖雪峰官方网站-python-web开发-使用模板

• 三个版面 : 主页, 登陆页面, 登陆成功页面

• 使用flask 中的render_template分离python代码和HTML

• 利用mysql储存用户数据

时间: 19.2.27.18.22

附录D-精简Python代码

装饰器 @decorator_name()

@porperty

@contextmanager

[^ 1]: 不同版本的python转化后的形式不同, 一般不用这种方法访问

Python计算机二级大纲摘要

高教版python语言程序设计

考试题型

| 题型 | 题量 | 分值 |

| ------------------- | ---- | ---- |

| 公共基础知识-选择题 | 10 | 10 |

| Python科目题-选择题 | 30 | 30 |

| 基本编程题 | 3 | 15 |

| 简单应用题 | 2 | 25 |

| 综合应用题 | 1 | 20 |

考试环境

• Python版本 : 3.5.3

• 系统环境 : Windows 7

• 开发环境 : python自带IDLE

考试范围

• python初学者难度, 不涉及面向对象编程

• python基本语法, python基本对象操作方法

• 需要掌握的标准库: turtle (必选) random (必选) time(可选)

• 需要掌握的第三方库: PyInstaller (必选) jieba(必选) wordcloud(可选)

网上题库

• python123

必考库-学习笔记

turtle

参考链接

python-turtle库详解 / 官方参考文档 / turtle库的使用(笔记---有图推荐)

基本概念

窗体绘制

• 为绘图设置一块画布

• 前两个参数设置画布的宽度和高度, 后两个参数可选, 用于设置窗口左上角坐标位置, 没有设置时, 窗口默认居中

turtle.setup(width, height, startx, starty)

空间坐标系

• 笔头默认坐标(绝对坐标)位于画布中央, 坐标为(0, 0), 方向向右

• 使用turtle.goto控制笔头移动到任意坐标, 画布会记录下移动轨迹

| 命令 | 说明 |

| -------------------- | -------------------------------------------------- |

| turtle.bk(distance ) | 向当前画笔方向移动distance像素长度 |

| turtle.fd(distance) | 向当前画笔相反方向移动distance像素长度 |

| turtle.circle(r) | 画圆，半径为正(负)，表示圆心在画笔的左边(右边)画圆 |

• 简易示例

import turtle

while True:

    turtle.setup(width=800, height=500, startx=100, starty=100)

    turtle.goto(100, 100)

    turtle.goto(100, -100)

    turtle.goto(-100, -100)

    turtle.goto(-100, 100)

    turtle.goto(0, 0)

[图片上传失败...(image-b16b7e-1570431464292)]

角度坐标系

• 仅改变画笔方向, 不进行移动

• turtle.seth()传入参数为绝对角度, turtle.right()和turtle.left()为相对角度

| 命令 | 说明 |

| -------------------- | ---------------------------- |

| turtle.right(degree) | 顺时针移动degree° |

| turtle.left(degree) | 逆时针移动degree° |

| turtle.seth(angle) | 改变画笔的角度, 画笔始终朝外 |

画笔运动及属性的更多设置

待补充

python-turtle库详解

例题

# 使用turtle.td()函数和turtle.seth函数绘制长方形

import turtle

d = 0

for i in range(4):

    turtle.fd(200)

    d += 90

    turtle.seth(d)

random

random常用用法

• random.choice(list_name): 选取list中的随机元素

PyInstaller

jieba

Github-jieba-中文文档

基本概念

• jieba用于拆分中文文档, 会对文字及符号进行拆分, 其中HMM参数不要求掌握

• jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型

• jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细

• 待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8

• jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)，或者用

• jieba.lcut 以及 jieba.lcut_for_search 直接返回 list

• jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。

import jieba

test = '今天的饭真好吃'

# 全模式, 返回一个生成器,使用for...in语句迭代元素

a_test = jieba.cut(test, cut_all=True)

'''

直接返回包含所有元素的列表, 若不指定cut_all参数, 则默认设置为精确模式, 即 cut_all=False

'''

b_test = jieba.lcut(test, cut_all=True)

# 精确模式

c_test = jieba.lcut(test, cut_all=False)

search_test = jieba.cut_for_search(test)

search_test2 = jieba.lcut_for_search(test)

print(b_test)

print(c_test)

print(search_test2)

print(", ".join(a_test))

--------------------snip-----------------------

输出结果

全模式直接返回列表的输出结果

['今天', '的', '饭', '真好', '好吃']

精确模式下输出结果

['今天', '的', '饭', '真', '好吃']

搜索模式下输出结果

['今天', '的', '饭', '真', '好吃']

全模式下输出结果, 出现了非词组'真好'

今天, 的, 饭, 真好, 好吃

例题

# 计算字符串s中的中文字符个数和中文词语个数, 中字符包含中文标点符号

# 计算字符串s中的中文字符个数和中文词语个数

import jieba

import re

s = "中国特色社会主义进入新时代，我国社会主要矛盾已经转化为人民日益增长的美好生活需要和不平衡不充分的发展之间的矛盾。"

n = len(s)

s = ''.join(re.findall(u'[\u4e00-\u9fff]+', s)) # 设置提取中文的正则表达式, 过滤标点符号

test_a = jieba.lcut(s, cut_all=False)

# print(test_a)

m = len(test_a)

print("中文字符数为{}，中文词语数为{}。".format(n, m))

个人知识盲点补充

进制转换

# 其他进制转十进制 decimal

>>> int('待转换数', 待转换数进制)

# 十进制转其他进制

转十六进制 hexadecimal

>>> hex(dec)

转八进制 octonary

>>> oct(dec)

转二进制 binary

>>> bin(dec)

%与format用法

python基础-格式化输出

%用法

• 输出整数

print('%o' %20)  # 输出八进制

print('%d' %20)  # 输出十进制

print('%x' %20)  # 输出十六进制

• 输出浮点数

待补充

• 输出字符串

待补充

format用法

• 位置匹配

'''

format函数传入元素具有下标索引, 可以在花括号用数字指定使用特定索引的元素, 元素可以重复使用, 也可以使用关键字参数定位

'''

# 不带参数

print('{} {}').format('hello', 'world')

# 重复使用hello

print('{0} {0} {1}').format('hello', 'world')

# 使用关键字参数定位

print('{'f'} {'s'}').format('f'='hello', 's'='world')

• 格式转换

'''

花括号中除了指定位置参数外, 还可以指定格式符

'''

# 输出十进制

print('{位置参数:b}').format(20)

# 输出八进制

print('{位置参数:o}').format(20)

# 输出十六进制

print('{位置参数:x}').format(20)

# 待补充

• 填充

正则表达式

待补充

翻转列表

a = (1,2,3,4)

a[::-1]  # 结果为(4,3,2,1)

基础习题集

from collections import Counter

ls = ["综合", "理工", "综合", "综合", "综合", "综合", "综合", "综合", "综合", "综合",

      "师范", "理工", "综合", "理工", "综合", "综合", "综合", "综合", "综合", "理工",

      "理工", "理工", "理工", "师范", "综合", "农林", "理工", "综合", "理工", "理工",

      "理工", "综合", "理工", "综合", "综合", "理工", "农林", "民族", "军事"]

for x, y in Counter(ls).items():

    print(x+':'+str(y))