python3 学习新手速成(赠柳哥)

作者: 王哈哈就很棒 | 来源:发表于2020-05-12 18:55 被阅读0次

python各版本的国内下载地址
https://mirrors.huaweicloud.com/python/

语法基础

第一部分

# print用于向控制台打印内容
# 打印数字
print(333) 
# 打印文本内容
print('hello', '狗不理')
# 打印多个内容, 用英文逗号隔开
print(231, 888, 'world', 33+58)
# 打印10次内容
print('hello' * 10)

# 变量相关操作
name = "王哈哈"
age = 23

print("你的名字是:", name, "年龄是:", age)
print("你的名字是%s, 你的年龄是:%d" % (name, age))

# 获取字符长度
print("你的名字长度是:", len(name))
print("welcome字符长度是:", len("welcome"))

# 其它操作
# 加减乘除操作
print("3+5=", 3+5)
print("6-2=", 6-2)
print("5*6=", 5*6)
print("5/2=", 5/2)

# 求余数
print("5除2余数是5%2=", 5%2)

第二部分

# 列表（一堆数据组成的列表）
# 数组下标(序号)从零开始
users = ['古力娜扎', '迪丽热巴', '王哈哈', '欧阳娜娜']

print('列表长度:', len(users))
print("users->", users)

# 打印列表下标为2的元素
print("users[2]->", users[2])
# 打印列表最后一个元素
print("users[-1]->", users[-1])
# 打印列表下标从1到3(不包含下标3)的元素
print("users[1:3]->", users[1:3])
# 打印整个列表
print("users[:]->", users[:])
# 修改列表的值
users[2] = "牛皮"
print("users->", users)
# 删除列表中的元素（pop是指删除列表最后一个元素）
users.pop()
print('pop后的users->', users)
# 删除指定元素
del users[1]
print('del后的users->', users)
# 向列表末尾追加元素使用append
users.append('佟丽娅')
# 向列表中追加多个元素
users += ['柳岩', '郑爽']
print(users)
# 向列表的指定位置插入元素insert
users.insert(0, '李沁')
print(users)
# 移除列表中第一个匹配项
list1 = [1, 3, 2, 1, 6]
list1.remove(1)
print(list1)
# 反向列表中元素
list1 = ['h', 'e', 'l', 'l', 'o']
print(list1)
# 列表排序, 默认升序排列
# list.sort(cmp=None, key=None, reverse=False)
list1 = [8, 2, 9, 7, 3, 6]
list1.sort()
print(list1)

# 元祖（和列表类似，不能修改）
users = ('古力娜扎', '迪丽热巴', '王哈哈', '欧阳娜娜')

print('数组长度:', len(users))
print("users->", users)

# 打印元祖下标为2的元素
print("users[2]->", users[2])
# 打印元祖最后一个元素
print("users[-1]->", users[-1])
# 打印元祖下标从1到3(不包含下标3)的元素
print("users[1:3]->", users[1:3])
# 打印整个元祖
print("users[:]->", users[:])

# 字典
info = {'name': '王哈哈', 'age': 23}
print('info->', info)
print("info['name']->", info['name'])
print("info['age']->", info['age'])

# 对字典添加属性
info['sex'] = '男'
print('info->', info)

# 删除字典的属性
del info['name']
print('删除后的字典info->', info)

第三部分

# 认识一下什么是条件成立
# 普及一个真和假的概念  真(True)  假(False)
# 比如 1+1=3 就是假的 False
# 比如 1+1=2 就是真的 True

# 条件判断
sex = "男"

# 条件成立走if后的执行区域，条件不成立走else区域
if sex == "男":
    # 条件成立执行区域
    print("你是个男的")
else:
    # 条件不成立执行区域
    print("你是个女的")


# 多个条件判断, 条件满足哪个就走哪个执行区域
level = 2

if level == 1:
    print("你是一级会员")
elif level == 2:
    print("你是二级会员")
elif level == 3:
    print("你是三级会员")
elif level == 4:
    print("你是四级会员")
else:
    print("你啥也不是")


# 满足多个判断条件用and
# 比如: 你需要有手机和电脑才能开网店，换成代码逻辑如下
# 同时满足用 and
phone = True
computer = False

if phone and computer:
    print('可以的，你可以开网店了')
else:
    print('你不能开网店')

# 两个条件满足其中一个条件用 or
if phone or computer:
    print('你满足了条件')
else:
    print('你不满足条件')

# 取反操作，就是把假的变真的，把真的变假的
marks1 = True
marks2 = False

print(not marks1)
print(not marks2)

第四部分

# 数据类型
# 数据类型就是值数据的类型
# 使用type()可得到数据的类型

print(type('abc'))
print(type(123))
print(type(6.8))
print(type(True))
print(type((1, 3, 2)))
print(type([1, 2, 2]))
print(type({'name': '王哈哈'}))

# 可得到以下内容
# <class 'str'>
# <class 'int'>
# <class 'float'>
# <class 'bool'>
# <class 'tuple'>
# <class 'list'>
# <class 'dict'>

# 类型转换
# int类型转为str类型
print("int转str后的类型是->", type(str(123)))
print("str转int后的数据类型是->", type(int("998")))
print("float转int后的数据类型是->", type(int(23.5)))

第五部分

# 循环，执行重复步骤的流程，两种语法for和while
# for循环
# 打印0-99
# 这里range(0, 100), 括号中有两个数，表示开始到结束的范围，
# 0表示从0开始，100表示截止到100，不包含100

for i in range(0, 100):
    # 循环执行的区域
    print("打印的数是->", i)


# 循环一个列表
for user in ['古力娜扎', '迪丽热巴', '王哈哈', '欧阳娜娜']:
    print("拿到的user->", user)

users = ['古力娜扎', '迪丽热巴', '王哈哈', '欧阳娜娜']
for user in users:
    print(user)

# 循环一个字符串
for char in '王哈哈':
    print("字符是->", char)

# 遍历一个字典的key(属性名), 第一种方法
users = {'name': '王哈哈', 'age': 23, 'sex': '男'}
for key in users:
    print("key=", key)

# 遍历一个字典的key(属性名), 第二种方法
for key in users.keys():
    print("key=", key)

# 遍历一个字典的value(值)
for value in users.values():
    print('value=', value)

# 编列一个字典的key和value
for key, value in users.items():
    print("key=", key, "value=", value)



# while 循环
num = 0

while num < 10:
    print("num->", num)
    num += 1

# while 遍历列表
users = ['古力娜扎', '迪丽热巴', '王哈哈', '欧阳娜娜']

num = 0
while num < len(users):
    print(users[num])
    num += 1

# 死循环，条件永远成立
# while True:
#     # 条件成立执行区域
#     print('xxx')

第六部分

# 函数，多次使用大段类似代码时需要用到的东西
def hello():
    # 函数体区域，可以些大段代码
    # xxxxx
    print('这里是函数体的内容')
    print('吧啦 吧啦 吧啦')

# 调用函数
hello()


# 函数传参数
def customSum(a, b):
    print( "%d+%d=%d" % (a, b, a+b) )

customSum(35, 28)


# 函数返回值
def customSum2(a, b):
    return a+b

a = 65
b = 77
sum_num = customSum2(65, 77)
print( '%d+%d的总和是=%d' % ( a, b, sum_num) )

第七部分

字符串相关操作

"""字母大小写转换"""
# 首字母大写
print('hello world'.title())

# 返回全大写
print('hello world'.upper())

# 返回全小写
print('Hello World'.lower())

# 字符串大小写交换
print('Hello World'.swapcase())


"""字符串检查"""
# 检查字符串是否由字母和数字组成(空格既不是数字也不是字母)
print('abc123'.isalnum())

# 检查字符串中是否只有字母
print('hello'.isalpha())

# 检查字符串字符是否全为数字
print('12345'.isdigit())

# 检查字符串是否为全小写
print('hello'.islower())

# 检查字符串是否为全大写
print('hello'.isupper())

# 检查字符串字符是否为标题式样
print('Hello World'.istitle())

# 检查字符串字符是否以特定字符开头
print('hello world'.startswith('he'))

# 检查字符串字符是否以特定字符结尾
print('hello world'.endswith('d'))


"""字符串切割，连接"""
# 字符串按指定字符分割
print('1,2,3,4,5'.split(','))

# 去除字符串首位指定字符
print('-hello world-'.strip('-'))

# 去除字符串左边字符
print('-hello'.lstrip('-'))

# 去除字符串右边字符
print('hello-'.lstrip('-'))

# 字符串连接
print('-'.join('hello'))


"""字符串的查找与替换"""
# 统计某个字符出现的次数
print('hello world'.count('o'))

# 字符串首字母大写
print('hello world'.capitalize())

# 找到指定字符返回下标，若有多个时返回第一个；若不存在返回-1
print('hello world'.find('o'))

# 找到指定字符返回下标，若有多个时返回第一个；若不存在报错
print('hello world'.index('o'))

# 字符串替换
print('hello world'.replace('l', 'a'))

# 字符串两边填充指定字符
print('hello world'.center(30, '-'))

面向对象（比较抽象，不会也没事，后面慢慢就会了）

# 面向对象
# 比较抽象的概念
# 区分类和对象  类是一种东西的框架  比如说手机， 手机有屏幕，按钮，可以打电话，上网
# 而对象就是类的实例， 比如说小米手机，华为手机，锤子手机等等
# 看实例吧，语法

class Phone:
    # 类的属性
    name = ''
    width = 0
    height = 0

    # 类的方法
    def call(self):
        print('打电话...')
    
    def internet(self):
        print('上网...')
    
# 实例化一个类
# 这里p1就是一个Phone对象， p1就拥有name, width, height属性，也可以调用call()方法, internet()方法
p1 = Phone()

# 为对象属性赋值
p1.name = '小米手机'
p1.width = 50
p1.height = 90

# 调用对象的方法
p1.call()
p1.internet()

# 打印对象的属性
print(p1.name)
print(p1.width)
print(p1.height)


# 使用构造函数
class Server:
    # 构造函数用户初始化对象
    def __init__(self, host, port, username, password):
        self.host = host
        self.port = port
        self.username = username
        self.password = password
    
    # 远程桌面方法
    def remote(self):
        print('调用了远程桌面的方法...')

    # 开机方法
    def open(self):
        print('打开了%s服务器...' % self.host)

    # 关机方法
    def shutdown():
        print('关闭了服务器')

# 新建一个Server对象, 这时候要传入__init__构造函数里面指定需要传的参数host, port, username, password
s1 = Server('127.0.0.1', 3389, 'admin', '111111')

# 调用对象的方法
s1.remote()
s1.open()


# 类的继承， 待更新

装饰器

# 不修改函数代码的情况下对传给函数的数值加2
def add_func(func):
    def inner(*args, **kwargs):
        return func(args[0] + 2)
    return inner


@add_func
def test(x):
    print(x)


test(3)

多装饰器执行顺序

def test1(func):
    def inner(*args, **kwargs):
        print('test1')
        return func(*args, **kwargs)
    return inner


def test2(func):
    def inner(*args, **kwargs):
        print('test2')
        return func(*args, **kwargs)
    return inner


def test3(func):
    def inner(*args, **kwargs):
        print('test3')
        return func(*args, **kwargs)
    return inner


@test1
@test2
@test3
def hello():
    pass


hello()

执行结果

test1
test2
test3

打印颜色

前景色	背景色	颜色
30	40	黑色
31	41	红色
32	42	绿色
33	43	黃色
34	44	蓝色
35	45	紫红色
36	46	青蓝色
37	47	白色

显示方式	意义
0	终端默认设置
1	高亮显示
4	使用下划线
5	闪烁
7	反白显示
8	可见

语法

print('\033[显示方式;前景色;背景色m + 结尾部分：\033[0m')

实例

print("显示方式：")
print("\033[0;37;40m\t万事如意\033[0m")
print("\033[1;37;40m\t万事如意\033[0m")
print("\033[22;37;40m\t万事如意\033[0m")
print("\033[4;37;40m\t万事如意\033[0m")
print("\033[24;37;40m\t万事如意\033[0m")
print("\033[5;37;40m\t万事如意\033[0m")
print("\033[25;37;40m\t万事如意\033[0m")
print("\033[7;37;40m\t万事如意\033[0m")
print("\033[27;37;40m\t万事如意\033[0m")

print("前景色：")
print("\033[0;30;40m\t万事如意\033[0m")
print("\033[0;31;40m\t万事如意\033[0m")
print("\033[0;32;40m\t万事如意\033[0m")
print("\033[0;33;40m\t万事如意\033[0m")
print("\033[0;34;40m\t万事如意\033[0m")
print("\033[0;35;40m\t万事如意\033[0m")
print("\033[0;36;40m\t万事如意\033[0m")
print("\033[0;37;40m\t万事如意\033[0m")

print("背景色：")
print("\033[0;37;40m\t万事如意\033[0m")
print("\033[0;37;41m\t万事如意\033[0m")
print("\033[0;37;42m\t万事如意\033[0m")
print("\033[0;37;43m\t万事如意\033[0m")
print("\033[0;37;44m\t万事如意\033[0m")
print("\033[0;37;45m\t万事如意\033[0m")
print("\033[0;37;46m\t万事如意\033[0m")
print("\033[0;37;47m\t万事如意\033[0m")

使用ecolor库打印颜色pip3 install ecolor

from ecolor import *

color('hello')
color('hello', color_white, bg_black)
color('hello', color_white, bg_black, display_highlighting)
color('hello', color_white, bg_black, display_underline)
color('hello', color_black, bg_white)

color('hello', color_red, bg_black)
color('hello', color_green, bg_black)
color('hello', color_blue, bg_black)
color('hello', color_purplish_red, bg_black)
color('hello', color_cyan_blue, bg_black)
color('hello', color_white, bg_black)

color('hello', color_white, bg_red)
color('hello', color_white, bg_green)
color('hello', color_white, bg_yellow)
color('hello', color_white, bg_blue)
color('hello', color_white, bg_purplish_red)
color('hello', color_white, bg_cyan_blue)
color('hello', color_white, bg_white)

库的学习（应用篇）

# 导入第三方库或内置标准库
# 之前学的都是一些简单的python语法
# 要想使用实际的功能需要借助python内置标准库或其它第三方库(别人为我们封装好的库)
# 比如: 时间，系统，磁盘，随机数，定时执行，多线程, socket网络编程, web编程, 数据库操作
# 都是需要借助其它库来完成的
# 下面就一一学习就好了
# 使用其它库之前需要导入
# 比如这里使用os库
import sys
import os

# 这里就使用了所导入的库
print("当前所在磁盘路径是->", os.getcwd())
print("当前Python的版本是->", sys.version)

时间操作 time库

# 时间相关
# 时间相关的操作涉及python中两个标准库  time库和datetime库
import time

print('当前时间戳->', time.time())

# 可以接受一个unix时间戳，然后转换为struct_time。
# 如果不传入second参数，则会返回当前时间的时间戳的struct_time对象
print(time.localtime())
print(time.localtime(time.time()))

print(time.struct_time)

# 和localtime函数类似，默认情况gmtime函数获取当前时间的utc时间。
# 返回当前时间的utc时间的struct_time对象。
# 也可以传入任意的unix时间戳，来得到utc时间
print(time.gmtime())

# 将一个时间戳struct_time对象转换为时间戳。
print(time.mktime(time.localtime()))

# 传入一个struct_time对象，返回"Wed May 13 11:04:57 2020"这种格式的字符串。
# 不传参数，返回当前时间的这种格式的字符串。
print(time.asctime(time.localtime()))

# 格式化时间 2020-05-13 11:05:50 这种格式
"""
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
"""
print(time.strftime("%Y-%m-%d %H:%M:%S"))
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 将字符串时间转为struct_time，time.strftime()的反向操作
print(time.strptime("2020-05-13 11:05:50", "%Y-%m-%d %H:%M:%S"))

# 让当前程序休眠指定秒数，也就是等待指定秒数后再运行, 这里hello world会在3秒后执行
time.sleep(3)
print('hello world')

日期时间操作 datetime 库

# datatime模块重新封装了time模块，提供更多接口
import datetime

print('现在日期时间是->', datetime.datetime.now())
print('今天日期是->', datetime.datetime.today())

# 格式化时间
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
print(datetime.datetime.now().isoformat())
# 获取日期
print(datetime.datetime.now().date())
# 获取时间戳
print(datetime.datetime.now().timestamp())
# 返回日期元祖
print(datetime.datetime.now().isocalendar())
# 返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推
print(datetime.datetime.now().isoweekday())
# 返回一个当前utc时间的datetime对象
print(datetime.datetime.utcnow())
# 将格式字符串转换为datetime对象
d = datetime.datetime.strptime("2020-05-03 18:00:21", "%Y-%m-%d %H:%M:%S")
print(d.now(), d.weekday())

# timedelta类，增加时间，减少时间
# 使用timedelta可以在日期上做天days，小时hour，分钟，秒，毫秒，微秒的时间计算
print('3天后的日期时间是->', datetime.datetime.now() + datetime.timedelta(days=3))
print('5个小时前的日期时间是->', datetime.datetime.now() - datetime.timedelta(hours=5))
print('21秒后的日期时间是->', datetime.datetime.now() + datetime.timedelta(seconds=21))

日期时间增减操作-附加

# 日期时间增减操作
# 使用标准库datetime操作
print("当前时间是:", datetime.datetime.now())
# 周，日，时，分，秒，毫秒，微秒增减操作, 但是不能对年，月份进行增减操作
print('周，日，时，分，秒，毫秒，微秒增减操作: ', (datetime.datetime.now() + datetime.timedelta(weeks=2, days=3, hours=1, minutes=3, seconds=5, milliseconds=3, microseconds=2)))


# 对年进行操作需要使用第三方库 pip3 install python-dateutil
from dateutil.relativedelta import relativedelta

# 年月增减操作，当然也可以对周，日，时，分，秒等日期时间单位进行增减操作
print(datetime.datetime.now() + relativedelta(years=3, months=2))

随机数操作

# random模块用于生成随机数
import random

# 生成一个0到1的随机浮点数：大于0 小于 1.0
print(random.random())

# 生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限
print(random.uniform(1, 8))

# 生成一个指定范围内的整数。其中参数20是上限，参数50是下限
print(random.randint(20, 50))

# 从指定范围内，按指定基数递增的集合中 获取一个随机数
print(list(range(1, 20, 2))) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
print(random.randrange(1, 20, 2)) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] 从生成的范围列表中内随机选一个

# 从序列中获取一个随机元素
print(random.choice(['王哈哈', '古力娜扎', '迪丽热巴', '欧阳娜娜']))

# 将一个列表中的元素打乱,即将列表内的元素随机排列
list1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print('随机打乱后的列表->', list1)

# 从指定序列中随机获取指定长度的片断并随机排列。
# 就是第二个参数就是指定从list1列表中随机拿几个元素
list1 = [1, 2, 3, 4, 5]
print(random.sample(list1, 2))

文件操作

# 文件操作
# 如果文件不存在则会出现 FileNotFoundError: [Errno 2] No such file or directory: 'abc.txt'
""" 文件打开的模式:
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【可读；   不存在则创建；存在则只追加内容】
"+" 表示可以同时读写某个文件

r+， 读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+， 写读【可读，可写】
"b"表示以字节的方式操作

rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
"""

# 读文件
f = open('abc.txt', 'r')
print('文件名是->', f.name)
print('文件是否关闭->', f.closed)
print('文件的访问模式是->', f.mode)

print("读取的文件内容是->", f.read())
# 操作完文件的时候要记得关闭文件， 关闭后不能再进行写入
f.close()


# 向文件里写内容, 模式为w会把之前文件里的内容给覆盖掉
f = open('abc.txt', 'w')
f.write('abc\n')
f.write('defghijkl')
f.close()

# 向文件里追加内容, 模式为a向文件末尾追加内容，不会覆盖之前文件里的内容
f = open('abc.txt', 'a')
f.write('\nhello\n')
f.write('world')
f.close()

# 文件定位
f = open('abc.txt')
print("当前文件内指针位置->", f.tell())

# seek方法可以改变当前文件的位置 seek(offset [,from])
# offset变量表示要移动的字节数, from变量指定开始移动字节的参考位置
# 如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。
# 如果设为1，则使用当前的位置作为参考位置。
# 如果它被设为2，那么该文件的末尾将作为参考位置。

# 把指针再次重新定位到文件开头
position = f.seek(0, 0)
print(f.read(2))
f.close()

# 读取一行文件
f = open('abc.txt', 'r')
print(f.readline())
f.close()

包管理工具使用

# pip是python的一个包管理工具, 你可以用它来下载安装python的第三方库，卸载库等等
# pip是先下载后安装，如果安装失败，也会清理干净，不会留下一个中间状态。

# 查看pip版本
pip -V

# 升级pip
pip install --upgrade pip

# 查看已安装第三方包列表
pip list

# pip安装第三方包
pip install 包名

# 升级指定包
pip install -U 包名

# 查看安装包详细信息
pip show 包名

# 卸载第三方包
pip uninstall 包名

# pip使用国内pypi镜像
pip install -i https://pypi.douban.com/simple/ 包名

# 安装包的指定版本号
pip install -i https://pypi.douban.com/simple/ 包名==版本号

# 以需求格式输出已安装的包
pip freeze

# 从文件中批量安装指定包
pip install -r requirements.txt

读写配置文件

config.ini

[config]
host = 127.0.0.1
port = 8080
username = admin
password = 111111

[data]
size = 25
width = 100
height = 200

main.py

# 读取配置文件
# 安装configparser模块
# pip3 install configparser -i https://pypi.douban.com/simple
import configparser

cfg = configparser.ConfigParser()

# 读取配置文件
cfg.read('config.ini')

# 获取section就是获取所有[]分组
print(cfg.sections())

# 判断是否有指定section
print(cfg.has_section("config"))

# 判断section是否有对应的option
print(cfg.has_option("config", "username"))

# 获取指定section下的option
print(cfg.get("config", "host"))
print(cfg.getint("config", "port"))
print(cfg.get("config", "username"))
print(cfg.get("config", "password"))
print(cfg.get("data", "size"))

# 得到section下的所有option
print(cfg.items("config"))


# 修改配置文件
cfg.set("config", "host", "192.168.1.1")
print("修改后的值是->", cfg.get("config", "host"))

# 从section中移除option
cfg.remove_option("config", "host")

# 从配置文件中移除section
cfg.remove_section("config")

# 将修改后的配置写入到文件中
cfg.write(open('config.ini', "w"))

JSON

import json

# 将字符串转化为json串（dumps)
json_str = "hello world"
print(json.dumps(json_str))

# 将列表转化为json串（dumps)
users = ['abc', 'def', '123', 456]
print(json.dumps(users))

# 转化字典为json串时，进行排序（dumps)
info = {'name': '王哈哈', 'age': 23, 'sex': '男'}
print(json.dumps(info))

# json串缩进（dumps)
info = {'name': 'wanghaha', 'age': 23, 'sex': 0}
print(json.dumps(info, indent=4))

# json字符串输出到文件
info = {'name': 'wanghaha', 'age': 23, 'sex': 0}
f = open('example.json', 'w')
json.dump(info, f, indent=4)
f.close()

# 将json串解码为列表（loads）
json_str = """{"name": "王哈哈", "age": 23}"""
print(json.loads(json_str))
print(json.loads(json_str)['name'])
print(json.loads(json_str)['age'])

# 从文件中读取json字符串
f = open('example.json')
json_data = json.load(f)
print(json_data)
print(json_data['name'])
f.close()

http请求与响应

# 待更新

数据库操作

# 安装 pymysql
# pip3 install pyinstall -i https://pypi.douban.com/simple

import pymysql


# 增加操作
def insert():
    # 连接数据库, 返回连接对象
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='fanhaokj', db='test')
    # 得到数据库游标
    cursor = conn.cursor()
    # 执行sql语句
    cursor.execute("""insert into user(`name`, `age`) value('欧阳娜娜', 21); """)
    # 提交sql语句
    conn.commit()
    # 关闭游标
    cursor.close()
    # 关闭数据库连接
    conn.close()


# 删除操作
def delete():
    # 连接数据库, 返回连接对象
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='fanhaokj', db='test')
    # 得到数据库游标
    cursor = conn.cursor()
    # 执行sql语句
    cursor.execute("""delete from user where name='欧阳娜娜'; """)
    # 提交sql语句
    conn.commit()
    # 关闭游标
    cursor.close()
    # 关闭数据库连接
    conn.close()


# 修改操作
def update():
    # 连接数据库, 返回连接对象
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='fanhaokj', db='test')
    # 得到数据库游标
    cursor = conn.cursor()
    # 执行sql语句
    cursor.execute("""update user set age=23 where age=21; """)
    # 提交sql语句
    conn.commit()
    # 关闭游标
    cursor.close()
    # 关闭数据库连接
    conn.close()


# 查询操作
def query():
    # 连接数据库, 返回连接对象
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='fanhaokj', db='test')
    # 得到数据库游标
    cursor = conn.cursor()
    cursor.execute('select * from user')
    # fetchall接收全部的返回结果行
    result = cursor.fetchall()
    print(result)
    # 关闭游标
    cursor.close()
    # 关闭数据库连接
    conn.close()


# 查询操作-返回字典类型
def queryDict():
    # 连接数据库, 返回连接对象
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='fanhaokj', db='test')
    # 得到数据库游标
    cursor = conn.cursor(pymysql.cursors.DictCursor)
    cursor.execute('select * from user')
    # fetchall接收全部的返回结果行
    result = cursor.fetchall()
    print(result)
    # 关闭游标
    cursor.close()
    # 关闭数据库连接
    conn.close()


if __name__ == '__main__':
    # 调用查询函数
    query()
    # 查询操作-返回字典类型
    queryDict()

封装mysql操作类

import pymysql


# mysql操作类
class MySql:
    def __init__(self, host, username, password, database, port=3306, charset='utf8'):
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self.database = database
        self.charset = charset

    # 连接mysql方法
    def _connect(self):
        return pymysql.connect(host=self.host,
                               port=self.port,
                               user=self.username,
                               passwd=self.password,
                               db=self.database,
                               charset=self.charset)

    # 插入方法
    def insert(self, sql):
        conn = self._connect()
        cursor = conn.cursor()
        cursor.execute(sql)
        conn.commit()
        affected_rows = conn.affected_rows()
        cursor.close()
        conn.close()
        return affected_rows

    # 修改方法
    def update(self, sql):
        conn = self._connect()
        cursor = conn.cursor()
        cursor.execute(sql)
        conn.commit()
        affected_rows = conn.affected_rows()
        cursor.close()
        conn.close()
        return affected_rows

    # 删除方法
    def delete(self, sql):
        conn = self._connect()
        cursor = conn.cursor()
        cursor.execute(sql)
        conn.commit()
        affected_rows = conn.affected_rows()
        cursor.close()
        conn.close()
        return affected_rows

    # 查询所有数据，结果以元祖方式返回
    def query_all(self, sql):
        conn = self._connect()
        cursor = conn.cursor()
        cursor.execute(sql)
        data = cursor.fetchall()
        cursor.close()
        conn.close()
        return data

    # 查询所有数据，结果以字典方式返回
    def query_all_dict(self, sql):
        conn = self._connect()
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        cursor.execute(sql)
        data = cursor.fetchall()
        cursor.close()
        conn.close()
        return data

    # 查询单条数据，结果以元祖方式返回
    def query_one(self, sql):
        conn = self._connect()
        cursor = conn.cursor()
        cursor.execute(sql)
        data = cursor.fetchone()
        cursor.close()
        conn.close()
        return data

    # 查询单条数据，结果以字典方式返回
    def query_one_dict(self, sql):
        conn = self._connect()
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        cursor.execute(sql)
        data = cursor.fetchone()
        cursor.close()
        conn.close()
        return data

实例使用

import mysql

# 连接
m = mysql.MySql(host='127.0.0.1', port=3306, username='root', password='fanhaokj', database='test')

# 查询所有
result = m.query_all('select * from user')
print(result)

# 查询所有以字典方式返回
result = m.query_all_dict('select * from user')
print(result)

# 查询单个
result = m.query_one('select * from user')
print(result)

# 删除操作
m.delete('delete from user where id=3')

# 更新操作
m.update("""update user set name='迪丽热巴' where name='欧阳娜娜'""")

# 插入操作
num = m.insert("""insert into user(`name`, `age`) value('古力娜扎', 26);""")
print(num)

使用mysqlctl

pip install mysqlctl

from mysqlctl import MySQLCtl

host = '127.0.0.1'
port = 3306
username = 'root'
password = 'Aa.bb9988'
database = 'mydb'
mysql = MySQLCtl(host=host, port=port, username=username, password=password, database=database)
print(mysql.query_one('select * from article'))
print(mysql.query_one_dict('select * from article'))
print(mysql.query_all('select * from article limit 1'))
print(mysql.query_all_dict('select * from article limit 1'))
print(mysql.insert("""insert into article(`title`, `content`) values('hello', 'hello world') """))
print(mysql.update("""update article set title='world' where id=3"""))
print(mysql.delete("""delete from article where id=5"""))

多线程操作

# 多线程操作
# 同时执行多个任务
# 看例子
# 比如你想一边吃饭一边尿尿(啊 好变态)
import time
import threading


def eat():
    print("吃饭中...")
    # 吃饭用了3秒
    time.sleep(3)
    print("吃完了...")


def watchTV():
    print("看电视...")
    # 看电视用了5秒
    time.sleep(5)
    print("看完了...")


# 这样执行就要等吃完饭才能执行看电视的方法，总共需要8秒
# eat()
# watchTV()


# 使用多线程吃饭的同时看电视， 共用时5秒钟
t1 = threading.Thread(target=eat)
t2 = threading.Thread(target=watchTV)

# 开启t1,t2两线程
t1.start()
t2.start()

生成uuid

import uuid

# uuid1 生成基于计算机主机ID和当前时间的UUID
print(uuid.uuid1())

# uuid3 基于命名空间和一个字符的MD5加密的UUID
print(uuid.NAMESPACE_DNS)
print(uuid.NAMESPACE_OID)
print(uuid.NAMESPACE_URL)
print(uuid.NAMESPACE_X500)

# uuid4 随机生成一个UUID
print(uuid.uuid4())

# uuid5 基于命名空间和一个字符的SHA-1加密的UUID
uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')

# 根据十六进制字符生成UUID
x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
print(str(x))
print(x.bytes)
print(uuid.UUID(bytes=x.bytes))

任务调度(schedule库)

import schedule
import time

def job():
    print("I'm working...")

'''
每隔10分钟执行一次任务
每隔一小时执行一次任务
每天10:30执行一次任务
每周一的这个时候执行一次任务
每周三13:15执行一次任务
'''

schedule.every(10).minutes.do(job)
schedule.every().hour.do(job)
schedule.every().day.at("10:30").do(job)
schedule.every().monday.do(job)
schedule.every().wednesday.at("13:15").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

发送邮件

# 待更新

web编程

# 待更新

socket网络编程

客户端

import socket

# 创建 socket 对象
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 指定连接地址和端口
client.connect(('127.0.0.1', 10580))

# 发送消息(只能发送byte类型的数据)
client.send(b'hello world')

# 接收数据
data = client.recv(1024)

# 打印接收到的数据
print(data)

# 关闭 socket 连接
client.close()

服务器端

import socket

# 创建 socket 连接对象
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置监听地址和端口
server.bind(('127.0.0.1', 10580))

# 监听,并设置最大挂起连接数
server.listen()

print('wait...')

# 获取客户端的 scoket 对象 conn 和客户端的地址address(ip、端口号)
conn, addr = server.accept()
print('connect', *addr)

# 接收客户端发来的数据(必须是byte类型)
data = conn.recv(1024)

# 向客户端发送数据(必须是byte类型)
conn.send(data.upper())
print(data)

# 关闭 socket 连接
server.close()

信息通讯

客户端

import socket

# 创建 socket 对象
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 指定连接地址和端口
client.connect(('127.0.0.1', 10580))

# 循环发送接收数据
while True:
    # 从命令行输入数据
    msg = input('>>:')
    # 判断是否是空字符串,如果为空则重新输入
    if len(msg)==0:continue
    # 发送数据
    client.send(msg.encode('utf-8'))
    # 接收数据
    data = client.recv(1024)
    print(data.decode())
# 关闭 socket 连接
client.close()

服务器端

import socket

# 创建 socket 连接对象
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置连接地址和端口
server.bind(('127.0.0.1', 10580))

# 监听,并设置最大挂起连接数
server.listen(5)

print('等待连接...')

# 循环接收发送数据
while True:
    # 获取客户端的 scoket 对象 conn 和客户端的地址address(ip、端口号)
    conn, addr = server.accept()
    print('连接成功', *addr)
    # 循环接收发送数据
    while True:
        try:
            # 接收数据
            data = conn.recv(1024)
            print(*addr,data.decode('utf-8'))
            # 发送数据
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(*addr,'连接断开...')
            break
print('socket 正常退出..')
# 关闭 socket 连接
server.close()

系统命令交互(简单)

客户端

import socket

# 创建 socket 连接对象
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置连接地址和端口
client.connect(('127.0.0.1', 10580))

# 循环发送接收数据
while True:
    # 从命令行输入系统命令
    message = input('>>')
    # 判断是否是空字符串,如果为空则重新输入
    if len(message) == 0: continue
    # 发送命令到服务器端
    client.send(message.encode('utf-8'))
    # 接收服务器端发送来的结果
    data = client.recv(1024)
    print(data.decode('utf-8'))
# 关闭 socket 连接
client.close()

服务器端

import socket
import os

# 创建 socket 连接对象
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置连接地址与端口
server.bind(('127.0.0.1', 10580))

# 监听,并设置最大挂起连接数
server.listen(5)

print('等待连接...')

# 循环接收发送数据
while True:
    # 获取客户端的 scoket 对象 conn 和客户端的地址address(ip、端口号)
    conn, addr = server.accept()
    print('连接成功', *addr)

    # 循环接收发送数据
    while True:
        try:
            # 接收数据
            data = conn.recv(1024)
            # 发送数据
            conn.send(os.popen(data.decode('utf-8')).read().encode('utf-8'))
        except ConnectionResetError as e:
            print(*addr, '关闭连接...')
            break
print('正常关闭 socket 连接...')
# 关闭 socket 连接
server.close()

系统命令交互(升级)

客户端

'''
    需要注意的问题:
    中文问题 在计算字符长度里 len()  中文和英文的长度是不一样的   所在需要将中文decode('utf-8')后再求长度
'''
import socket

# 创建 socket 连接对象
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置连接地址和端口
client.connect(('127.0.0.1', 10380))

# 循环处理
while True:
    message = input('>>')
    # 判断为空重新输入
    if len(message.strip())==0:continue
    # 发送输入的命令
    client.send(message.encode('utf-8'))
    # 接收服务器端发送的结果长度
    result_size = client.recv(1024).decode('utf-8')
    recv_size = 0
    recv_data = b''
    print('接收到的大小是:', result_size)
    # 如果当前接收的长度小于服务器传来的结果长度则继续接收
    while recv_size < int(result_size):
        print('recvsize_start', recv_size)
        # 将本次接收数据保存在变量 data 里
        data = client.recv(1024)
        # 累加本次接收数据的长度
        recv_size += len(data)
        # 累加本次接收的结果
        recv_data += data
        print('recvsize_end',recv_size)
    else:
        # 接收完成
        print('data done !', recv_size)
        print(recv_data.decode('utf-8'))
# 关闭 socket 连接
client.close()

服务器端

import socket
import os

# 创建 socket 连接对象
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置连接地址和端口
server.bind(('127.0.0.1', 10380))
# 监听,并设置最大挂起连接数
server.listen(5)
# 循环处理
while True:
    print('wait...')
    # 获取客户端的 scoket 对象 conn 和客户端的地址address(ip、端口号)
    conn, addr = server.accept()
    print('connect success', *addr)
    while True:
        try:
            # 接收客户端发来的命令
            cmd = conn.recv(1024)
            # 将命令执行的结果保存在变量 result 中
            result = os.popen(cmd.decode('utf-8')).read()
            # 判断命令是否执行成功
            if len(result) == 0:
                result = 'command not found'
            print(len(result.encode('utf-8')))
            # 向客户端发送命令结果长度
            conn.send(str(len(result.encode('utf-8'))).encode('utf-8'))
            # 向客户端发送命令返回结果
            conn.send(result.encode('utf-8'))
        except Exception as e:
            print(addr, 'closed..')
            break
print('socket close..')
# 关闭 socket 连接
server.close()

发送文件

服务器端

import socket
import os

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('localhost', 10580))
server.listen(5)

print('wait...')
while True:
    conn, addr = server.accept()
    print('connect success', *addr)
    while True:
        try:
            filename = conn.recv(1024).decode('utf-8')
            if os.path.isfile(filename):
                # 发送文件大小
                filesize = os.stat(filename).st_size
                print('filesize', filesize)
                conn.send(str(filesize).encode('utf-8'))

                # 等待客户端开始接收文件信号(防止粘包)
                flag = conn.recv(1024)
                print('flag', flag)

                # 循环读取文件内容发给客户端
                f = open(filename, 'rb')
                for line in f:
                    conn.send(line)
                else:
                    print('done')
            else:
                print('is not file')
        except ConnectionResetError as e:
            print(*addr, 'closed...')
            break
server.close()

客户端


import socket
import os

client =  socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('localhost', 10580))
while True:
    filename = input('>>')
    client.send(filename.encode('utf-8'))

    # 接收文件大小
    file_total_size = int(client.recv(1024).decode('utf-8'))
    file_recv_size= 0
    print('接收到的文件大小', file_total_size)

    # send flag
    client.send(b'ok')

    # 接收来的文件起新的名字
    filename = os.path.join(os.path.dirname(filename), 'new_' + os.path.basename(filename))
    f = open(filename, 'wb')

    # 判断已接收到的大小是否小于总大小
    while file_recv_size < file_total_size:
        if file_total_size - file_recv_size >1024:
            size = 1024
        else:
            size = file_total_size - file_recv_size
        data = client.recv(size)
        f.write(data)
        file_recv_size += len(data)
        print(file_recv_size)
    else:
        f.close()
        print('done')
        print('file_total_size', file_total_size)
        print('file_recv_size', file_recv_size)
client.close()

os模块

import os

# 获取操作系统平台
print(os.name)

# 获取当前目录
print(os.getcwd())

# 获取指定目录下的文件
print(os.listdir(os.getcwd()))

# 运行shell命令, 执行成功返回0
print(os.system("pwd"))

# 删除某个文件
# os.remove('a.txt')

# 获取字典格式的环境变量
print(os.environ)

# 切换目录
os.chdir('/var/log')
print(os.getcwd())

# 得到用户登录名称
print(os.getlogin())

# 得到用户组名称列表
print(os.getgroups())

# 得到用户id
print(os.getuid())

# 得到组id
print(os.getgid())

# 得到环境变量
print(os.getenv('PATH'))

# 检测文件路径是否存在
print(os.path.exists('/etc/my.cnf'))

# 检测是否为文件
print(os.path.isfile('/etc/my.cnf'))

# 检测是否为目录
print(os.path.isdir('/usr/local'))

# 检测是否绝对路径
print(os.path.isabs('/etc/my.cnf'))
print(os.path.isabs('./data/abc.py'))

# 获取绝对路径
print(os.path.abspath('.'))

# 分离文件名与扩展名
print(os.path.splitext('/usr/local/nginx/conf/nginx.conf'))

# 拆分路径文件名
print(os.path.split('/usr/local/nginx/conf/nginx.conf'))

# 文件路径拼接
print(os.path.join('/usr/local', 'nginx/conf'))

# 返回文件名
print(os.path.basename('/usr/local/nginx/conf/nginx.conf'))

# 返回目录名
print(os.path.dirname('/usr/local/nginx/conf/nginx.conf'))

paramiko模块(控制linux)

# 待更新

pyjwt

pip3 install pyjwt

import jwt
import datetime

payload = {
    'exp': datetime.datetime.now() + datetime.timedelta(days=1),
    'iat': datetime.datetime.now(),
    'iss': 'wanghaha',
    'data': {
        'uid': 1001,
    }
}

# encode
e_str = jwt.encode(payload, key='hello', algorithm='HS256')
print(e_str)


# decode
d_str = jwt.decode(e_str, key='hello', issuer='wanghaha', algorithms=['HS256'])
print(d_str)

"""
exp
exp指过期时间，在生成token时，可以设置该token的有效时间，如果我们设置1天过期，1天后我们再解析此token会抛出
jwt.exceptions.ExpiredSignatureError: Signature has expired


nbf
nbf类似于token的 lat ，它指的是该token的生效时间，如果使用但是没到生效时间则抛出
jwt.exceptions.ImmatureSignatureError: The token is not yet valid (nbf)


iss
iss指的是该token的签发者，我们可以给他一个字符串。
注意，iss 在接收时如果不检验也没有问题，如果我们接收时需要检验但是又签名不一致，则会抛出
jwt.exceptions.InvalidIssuerError: Invalid issuer


aud
aud指定了接收者，接收者在接收时必须提供与token要求的一致的接收者（字符串），如果没写接收者或者接收者不一致会抛出
jwt.exceptions.InvalidAudienceError: Invalid audience


iat
iat指的是token的开始时间，如果当前时间在开始时间之前则抛出
jwt.exceptions.InvalidIssuedAtError: Issued At claim (iat) cannot be in the future.
"""

参数校验

pip3 install validpar

from validpar.validpar import CheckParams

cp = CheckParams()
cp.check([
    ['183xx', 'isphone', '手机号格式错误'],
    ['asdfas', 'isemail'],
    ['18', 'isint'],
    ['28.5', 'isfloat'],
    ["""{"name": "wanghaha", "age": 18}""", 'isjson']
])

print(cp.err_first_string())
print(cp.err_strings())

# 支持以下验证
"""
isascii()
isprintascii()
isnonempty()
isbase64()
isemail()
ishexadecimal()
isint()
isfloat()
ispositive()
isslug()
isuuid()
isuuid3()
isuuid4()
isuuid5()
isfullwidth()
ishalfwidth()
islatitude()
islongitude()
ismac()
ismd5()
issha1()
issha256()
issha512()
ismongoid()
isiso8601()
isbytelen()
isipv4()
isipv6()
isip()
isport()
isdns()
isssn()
issemver()
ismultibyte()
isfilepath()
isdatauri()
isjson()
istime()
isurl()
iscrcard()
isisin()
isiban()
ishexcolor()
isrgbcolor()
isphone()
isisbn()
isisbn10()
isisbn13()
isimei()
ismimetype()
isisrc()
"""

jieba

# 待更新

psutil模块(获取系统信息)

# 待更新

smtplib模块(发送邮件)

# 待更新

xlwt模块(操作excel)

# 待更新

chardet

# 待更新

celery 异步任务

pip3 install celery
celery_task.py

import celery
import time

backend = 'redis://127.0.0.1:6379/1'
broker = 'redis://127.0.0.1:6379/2'
cel = celery.Celery('test', backend=backend, broker=broker)


@cel.task
def send_msg(name):
    print('send msg %s' % name)
    time.sleep(5)
    print('send msg %s successful' % name)
    return 'ok'


@cel.task
def send_email(name):
    print('send email %s' % name)
    time.sleep(5)
    print('send email %s successful' % name)
    return 'ok'

执行异步命令行

celery worker -A celery_app_task -l info

demo.py

from celery_task import send_msg, send_email

result = send_msg.delay("hello")
print(result.id)

result2 = send_email.delay("world")
print(result2.id)

result.py

from celery.result import AsyncResult
from celery_task import cel

async_result = AsyncResult(id="1c46f4ed-7f63-4e6c-9d7d-319ccbdfa42b", app=cel)
print("result status:", async_result.status)

if async_result.successful():
    result = async_result.get()
    print(result)
    # result.forget() # 将结果删除
elif async_result.failed():
    print('执行失败')
elif async_result.status == 'PENDING':
    print('任务等待中被执行')
elif async_result.status == 'RETRY':
    print('任务异常后正在重试')
elif async_result.status == 'STARTED':
    print('任务已经开始被执行')

多任务结构

celery_tasks
- __init__.py
- celery.py
- task01.py
- task02.py
check_result.py
produce_task.py

celery_tasks/celery.py

from celery import Celery

cel = Celery('celery_demo',
             broker='redis://127.0.0.1:6379/1',
             backend='redis://127.0.0.1:6379/2',
             # 包含以下两个任务文件，去相应的py文件中找任务，对多个任务做分类
             include=['celery_tasks.task01',
                      'celery_tasks.task02'
                      ])

# 时区
cel.conf.timezone = 'Asia/Shanghai'
# 是否使用UTC
cel.conf.enable_utc = False

celery_tasks/task01.py

from celery_tasks.celery import cel
import time


@cel.task
def send_msg(name):
    print('send msg %s' % name)
    time.sleep(5)
    print('send msg %s successful' % name)
    return 'ok'

celery_tasks/task02.py

from celery_tasks.celery import cel
import time


@cel.task
def send_email(name):
    print('send email %s' % name)
    time.sleep(5)
    print('send email %s successful' % name)
    return 'ok'

check_result.py

from celery.result import AsyncResult
from celery_tasks.celery import cel

async_result = AsyncResult(id="57844f94-690e-4ab4-b7f2-aa188b79a5cb", app=cel)

if async_result.successful():
    result = async_result.get()
    print(result)
    print("result status:", async_result.status)
    # result.forget() # 将结果删除,执行完成，结果不会自动删除
    # async.revoke(terminate=True)  # 无论现在是什么时候，都要终止
    # async.revoke(terminate=False) # 如果任务还没有开始执行呢，那么就可以终止。
elif async_result.failed():
    print('执行失败')
elif async_result.status == 'PENDING':
    print('任务等待中被执行')
elif async_result.status == 'RETRY':
    print('任务异常后正在重试')
elif async_result.status == 'STARTED':
    print('任务已经开始被执行')

produce_task.py

from celery_tasks.task01 import send_msg
from celery_tasks.task02 import send_email

# 立即告知celery去执行test_celery任务，并传入一个参数
result = send_email.delay('hello')
print(result.id)

result = send_msg.delay('world')
print(result.id)

执行异步命令行

celery worker -A celery_tasks -l info -P eventlet

BeautifulSoup(爬虫页面解析)

# 待更新

multiprocessing(多进程)

# 待更新

Pygame(游戏引擎)

# 待更新

发布pypi

setup.py

from setuptools import setup
import setuptools

setup(
    name = 'mysqlctl',
    version = '1.0.0',
    author = '王哈哈',
    author_email = 'mail65656@163.com',
    description = '项目描述',
    long_description = '项目描述详细信息',
    packages = setuptools.find_packages(),
    platforms = 'any',
    classifiers = [
        'Programming Language :: Python :: 3',
        'License :: OSI Approved :: MIT License',
        'Operating System :: OS Independent'
    ],
    install_requires=[
        # 你的库依赖的第三方库（也可以指定版本）'
        'pymysql'
    ],
)

打包

python setup.py sdist

上传到pypi

twine upload dist/*

实战开发

# 待更新

python3 学习新手速成(赠柳哥)

语法基础

第一部分

第二部分

第三部分

第四部分

第五部分

第六部分

第七部分

面向对象（比较抽象，不会也没事， 后面慢慢就会了）

装饰器

打印颜色

语法

实例

库的学习（应用篇 ）

时间操作 time库

日期时间操作 datetime 库

随机数操作

文件操作

包管理工具使用

读写配置文件

JSON

http请求与响应

数据库操作

封装mysql操作类

使用mysqlctl

多线程操作

生成uuid

任务调度(schedule库)

发送邮件

web编程

socket网络编程

客户端

服务器端

信息通讯

客户端

服务器端

系统命令交互(简单)

客户端

服务器端

系统命令交互(升级)

客户端

服务器端

发送文件

服务器端

客户端

os模块

paramiko模块(控制linux)

pyjwt

参数校验

jieba

psutil模块(获取系统信息)

smtplib模块(发送邮件)

xlwt模块(操作excel)

chardet

celery 异步任务

多任务结构

BeautifulSoup(爬虫页面解析)

multiprocessing(多进程)

Pygame(游戏引擎)

更多第三方库

发布pypi

实战开发

恭喜你，你可以自己独当一面了！（光头警告）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Python

面向对象（比较抽象，不会也没事，后面慢慢就会了）

库的学习（应用篇）