Python基础语法

■（一）： 输出print()

输出

print()【用于输出到日志】

1
2
3
4
5
# print() 函数用来输出信息
print("helloWorld!")
print(15 * 20)
# 完整写法：end结束转义字符，sep分隔符，file输出到文件
print('helloWorld', 'python', end='\t', sep='*', file=open('demo_1.py', 'w'))

输出到文件

open() 【打开文件】

close() 【关闭文件】

1
2
3
4
5
# 将print() 数据输出到文件中
# a+ ：如果没有文件就创建文件，如果有，则在原有文件尾部追加
fp = open('D:/Users/user/Desktop/demo_1.txt', 'a+')
print('HelloWorld!', file=fp)
fp.close()

不换行

1
2
# 不进行换行输出
print("a", "b", "c")

转义字符

\n \t \r \b \\ \“ r

1
2
3
4
5
6
7
8
9
10
# 转义字符
print("hello\nWorld") # \n 换行
print("he\t\tllo\tWorld") # \t 水平制表
print("hello\tWo\trld")
print("hello\rWorld") # \r 回车覆盖
print("hello\bWorld") # \b 退格
print("http:\\\\www.baidu.com") # \\ 输出\
print("http://www.baidu.com") # 正确的网址是正斜杠
print("子曰：\"有朋自远方来\"") # \" 输出"
print(r"hello\nWorld") # r | R 让转义字符失效

进制转换

chr()【x进制转unicode字符】

ord()【unicode字符转十进制】

int(n,x)【x进制转十进制】

bin()【十进制转二进制】

oct()【十进制转八进制】

hex()【十进制转十六进制】

1
2
3
4
5
6
# 二进制
print(chr(0b100111001011000)) # 二进制转unicode
print(chr(97)) # 十进制转unicode
print(ord('乘')) # unicode转十进制
print(bin(20056)) # 十进制转二进制
print(bin(ord('法')))

标识符和保留字

1
2
# 标识符和保留字
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

基础变量

int float bool str

id()【获取对象内存地址】

type()【获取对象类型】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 变量 int float bool str
name = '小明'
print(name)
print('标识', id(name)) # 获取对象内存地址：指针
print('类型', type(name)) # 获取对象类型
name = '小红'
#
print(type(11))
print(type(15.84))
print(type(False))
print(type('字符'))
# int
print('二进制', bin(20))
print('十进制', 0b10100)
print('八进制', 0o14721)
print('十六进制', 0x2d3aef)
# float
print(1.1 + 2.2) # 浮点运算不精确
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2'))
# bool
print(True + False)
# str
str_1 = 'HelloWorld'
str_2 = "HelloWorld"
str_3 = '''HelloWorld,
HelloWorld'''
str_4 = """HelloWorld,
HelloWorld"""

强转

int()【强转为int】

float()【强转为float】

bool()【强转为bool】

str() 【强转为string】

1
2
3
4
5
6
7
8
9
10
# 强转 str() int() float() bool()
name = '张三'
age = 20
score = 60.5
_score = '60.5'
isMan = 1
print(name + str(age))
print(str(int(score)) + str(age))
print(float(_score))
print(bool(isMan))

注释

‘’’ ‘’’

1
2
3
4
5
6
# 注释
# 符号用于单行注释
'''三引号之间
用于多行注释'''
# coding:utf-8 # 用于编码解释

■（二）： 运算

输入

input()【允许接收日志实时的输入】

1
2
3
4
5
6
# 输入函数 input()
temp = input('晚上吃什么')
print(temp)
input_a = input('请输入a数值')
input_b = input('请输入b数值')
print(int(float(input_a)) + int(float(input_b)))

算数运算符

+ - * / % **

1
2
3
4
5
# 算术运算符 + - * / //(整除) % **(次幂)
print(1 + 2 - 3 * 4 // 5)
print(1 / 3)
print(12 % 5)
print(10 ** 2.5)

赋值运算符

= += -= *= /= %=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 赋值运算符 = += -= *= /= %=
int_a = 3 + 4
int_b = int_c = int_d = 3 + 4 # 链式赋值

int_a += 20
print(int_a)
int_a -= 10
print(int_a)
int_a *= 3
print(int_a)
int_a /= 2
print(int_a)
int_a %= 4
print(int_a)

int_e, int_f = 12, 13 # 解包赋值
print('e', int_e, 'f', int_f)
int_e, int_f = int_f, int_e # 交换赋值
print('e', int_e, 'f', int_f)

比较运算符

< >= <= == != is is not

1
2
3
4
5
6
7
8
9
10
11
# 比较运算符 > < >= <= == != is is not
bool_a = 3 < 4
bool_b = 3 >= 4
bool_c = 3 == 4
bool_d = 3 != 4
print(bool_a, bool_b, bool_c, bool_d)

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
print(list_1 is list_2) # is 比较判断的是地址
print(list_1 is not list_2) # is not 比较判断的是地址

逻辑运算符

and or not in not in

1
2
3
4
5
6
# 逻辑运算符 and  or  not  in  not in
print(3 < 4 and 3 != 4)
print(3 < 4 or 3 == 4)
print(not 3 < 4)
print('w' in 'Helloworld')
print('w' not in 'HelloWorld')

位运算符

& | << >>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 位运算符（将数据转为二进制再进行计算）
# &位与（二进制位中，相同位数字都为1，结果才为1）
# |位或（二进制位中，相同位数字都为0，结果才为0）
# <<左移位（向左移动一个二进制位，相当于*2，低位补齐0，高位舍弃）
# >>右移位（向右移动一个二进制位，相当于/2，低位舍弃，高位补齐0）
# 00000100——>4
# 00001000——>8
# 00000000——>4 & 8
print(4 & 8)
print(bin(4 & 8))
# 00000100——>4
# 00001000——>8
# 00001100——>4 | 8
print(4 | 8)
print(bin(4 | 8))
#  00000100——>4
# 000001000——>4 << 1
#   0000010——>4 >> 1
print(4 << 1)
print(bin(4 << 1))
print(4 >> 1)
print(bin(4 >> 1))

运算符优先级

1
2
3
4
5
6
# 运算符优先级
# 算数** */%// +-
# 位>><< & |
# 比较> < >= <= == !=
# 逻辑and or
# 赋值= += -= *= /= %=

■（三）： 程序结构

顺序结构

1
2
3
print('第一步')
print('第二步')
print('第三步')

分支结构

if-elif-else分支

if elif else

1
2
3
4
5
6
7
8
9
10
11
# 分支结构
print(bool(False), bool(0), bool(0.0), bool(None), bool(''), bool(""))
money = 1000
input_a = int(input('请输入取款金额'))
if input_a < money:
    money -= input_a
    print('取款成功，余额为', money)
elif input_a > money:
    print('余额不足')
else:
    print('余额为0')

三目运算符

1
2
3
4
5
6
# 三目运算符简化版 if else外的两个为变量，if else内为条件，满足条件输出前变量，不满足输出后变量
num_a = int(input('请输入A'))
num_b = int(input('请输入B'))
num_c = (num_a if num_a < num_b else num_b)
print(num_c)
print(True if 1 > 2 else False)

语法占位符

pass

1
2
3
4
5
# pass 语法占位符 当if等条件判断里为空执行时，不得留空，需要加pass
if 1 > 2:
    pass
else:
    print('HelloWorld')

循环结构

while循环

while

1
2
3
4
5
6
7
8
9
10
11
12
13
# while 循环
int_a = 0
while int_a < 10:
    int_a += 1
    print(int_a)

int_b = 0
int_c = 0
while int_b < 100:
    int_b += 1
    if int_b % 2 == 0:
        int_c += int_b
print(int_c)

for循环

for in enumerate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# for 循环
for i in range(10):
    print(i)
for j in 'Python':
    print(j)
for _ in range(5): # 如果不需要自定义变量，则可以使用_代替
    print('HelloWorld')

int_d = 0
for k in range(0, 101, 2):
    int_d += int(k)
print(int_d)

for l in range(100, 1000):
    l_1 = l // 100 # 百位
    l_2 = l % 100
    l_3 = l_2 // 10 # 十位
    l_4 = l_2 % 10 # 个位
    if l_1 ** 3 + l_3 ** 3 + l_4 ** 3 == l:
        print('水仙花数_' + str(l))

# 列表与遍历
list1 = ['hello', 'world', 'python']
for i, string in enumerate(list1):
    print(i, string)

break和continue

break

break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# break 跳出
for m in range(3):
    str_a = int(input('请输入密码'))
    if str_a == 110:
        print('密码正确')
        break
    print('密码错误')
n = 0
while n < 3:
    str_b = int(input('请输入密码'))
    if str_b == 110:
        print('密码正确')
        break
    print('密码错误')
    n += 1

continue

continue

1
2
3
4
5
# continue 跳级
for o in range(1, 51):
    if o % 5 != 0:
        continue
    print(o)

嵌套循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 嵌套循环
for p in range(5):
    for q in range(6):
        if p == 0 or p == 5 - 1 or q == 0 or q == 6 - 1:
            print('#', end='\t')
        else:
            print('', end='\t')
    print('')

for r in range(1, 10):
    for s in range(1, 10):
        if s <= r:
            print(r, '*', s, '=', r*s, end='\t')
    print('')

# 嵌套循环中的 break 和 continue 只会影响本层循环

■（四）： 序列range()

构造

range()【构造一个序列】

1
2
3
4
5
6
7
8
9
10
11
12
# range() 序列
r1 = range(10) # 重载1：range(a) 生成0~a的序列[0, a)
print(r1) # range() 是一个迭代器
print(list(r1)) # 将它变成列表

r2 = range(5, 10) # 重载2：range(a, b) 生成a~b的序列[a, b)
print(r2)
print(list(r2))

r3 = range(5, 10, 2) # 重载3：range(a, b, c) 生成a~b的序列[a, b) 步长为c
print(r3)
print(list(r3))

从属判断

1
2
3
4
5
# in 和 not in 用来判断某个数是否在序列中
if 2 in range(0, 6, 2):
    print('in')
elif 2 not in range(0, 6, 2):
    pass

长度

len()【求长度】

1
2
# len()
print(len(range(10)))

■（五）： 列表list()

构造

[]

list()【构造一个列表】

1
2
3
4
# 列表
list_a = ['helloWorld', 123, 3.14159, False, 123]
list_a2 = list(['helloWorld', 123, 3.14159, False])
print(list_a)

索引与查找

[]

index()【索引】

1
2
3
4
5
6
7
8
# 列表索引
print(list_a[0]) # 通过索引获取
#  0  1  2  3  4  0~n-1
# -5 -4 -3 -2 -1  -n~-1
print(list_a[-3]) # 通过索引获取
# .index()
print(list_a.index(123)) # 列表中有相同元素，则以靠前元素为基准
print(list_a.index(123, 1, 3)) # 在索引[1, 3)中查找

切片

[::]

1
2
3
4
5
6
# 列表切片 [开始:结束:步长]
list_b = [10, 20, 30, 40, 50, 60, 70, 80]
print(list_b[2:5:1])
print(list_b[1:6:2])
print(list_b[::]) # 默认[0:n-1:1]
print(list_b[::-1]) # 列表逆序

从属判断

in not in

1
2
3
# 列表查询 in  not in
list_c = [10, 20, 'HelloWorld', 'python']
print(10 in list_c)

长度

len()【求长度】

1
2
# len()
print(len([10, 20, 30]))

遍历

1
2
3
# 列表遍历
for i in list_c:
    print(i)

增删改

增加

append()【在末尾添加一个元素】

extend()【在末尾添加另外一个列表】

insert()【在任意位置插入一个元素】

[::]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 增加 append() extend() insert() 切片
list_d = [10, 20]
# append() 在末尾添加一个元素
list_d.append('hello')
print(list_d)
# extend() 在末尾添加另外一个列表
list_d.extend(['world', 'python'])
print(list_d)
# insert() 在任意位置插入一个元素
list_d.insert(2, 110) # 将110设为第二个元素，原先第二个元素被挤到后面
print(list_d)
# 切片 将原列表切掉，并在末尾添加另外一个列表
list_d[2:] = [250, 300] # 切掉序数后的列表，将新列表接在后面
print(list_d)
list_d[:2] = [400, 600] # 切掉序数前的列表，将新列表接在前面
print(list_d)

减少

remove()【删除某一个元素】

pop()【按序数删除一个元素】

[::]

clear()【清除列表内所有】

del【删除列表】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 减少 remove() pop() 切片 clear() del
list_e = [100, 200, 300, 400, 500, 600, 700, 100]
# remove() # 删除某一个元素，重复元素删除靠前
list_e.remove(100)
print(list_e)
# pop() # 按序数删除一个元素，没有序数则删除列表最后一个元素
list_e.pop(2)
print(list_e)
list_e.pop()
print(list_e)
# 切片 将列表切掉，然后不写替换列表
list_e[4:] = [] # 切掉序数后的列表
print(list_e)
list_e[:1] = [] # 切掉序数前的列表
print(list_e)
# clear() 清除列表内所有
list_e.clear()
print(list_e)
# del 删除列表
del list_e

修改

[::]

1
2
3
4
5
6
7
8
# 修改 切片
list_f = [100, 200, 300, 400, 500]
# 直接替换
list_f[2] = 301
print(list_f)
# 切片
list_f[1:3] = [210, 310]
print(list_f)

排序

reverse()【倒序排列】

sort()【升序排列】

sorted()【新建对象式的升序排列】

1
2
3
4
5
6
7
8
9
10
11
12
13
# 列表排序 sort()
list_g = [400, 300, 100, 500, 200]
list_g.reverse() # 倒序排列
print(list_g)
list_g.sort() # 升序排列
print(list_g)
list_g.sort(reverse=True) # 降序排列
print(list_g)
list_g2 = sorted(list_g) # 新建对象式的升序排列
print(list_g)
list_g2 = sorted(list_g, reverse=True) # 新建对象式的降序排列
print(list_g)

简写

1
2
3
4
5
6
# 列表简写 [使用例术式 for-in遍历]
list_h = [i for i in range(1, 10)]
print(list_h)
list_h2 = [(i + i * 10) for i in range(0, 5)]
print(list_h2)

■（六）： 字典dict()

构造

{:}

dict()【构造一个字典】

1
2
3
4
5
6
# 字典 键值对 hash(键) = 值
# key不允许重复，且是不可变对象，value可以
# 字典里的元素是无序的
dict_a = {'张三': 10, '李四': 12, '王五': 8}
dict_a2 = dict(name='张三', age=10)
dict_a3 = {}

索引与查找

[]

get()【字典索引】

1
2
3
4
# 字典索引
print(dict_a['李四'])
print(dict_a.get('张三'))
print(dict_a.get('孙六', 15))

从属判断

in not in

1
2
# 字典查询 in  not in
print('王五' not in dict_a)

长度

len()【求长度】

1
2
# len()
print(len({'张三': 10, '李四': 12, '王五': 8}))

增删

[]

del【字典删除】

clear()【字典清空】

1
2
3
4
5
6
7
# 字典增删 del clear()
del dict_a['王五']
print(dict_a)
dict_a['孙六'] = 11
print(dict_a)
dict_a.clear()
print(dict_a)

获取

keys()【获取键】

values()【获取值】

items()【获取键与值构成的元组】

1
2
3
4
5
6
7
8
# 字典获取 keys() values() items()
dict_b = {'张三': 10, '李四': 12, '王五': 8}
key_b = dict_b.keys()
print(key_b)
value_b = dict_b.values()
print(value_b)
item_b = dict_b.items()
print(item_b)

遍历

1
2
3
4
5
# 字典遍历
for i in dict_b:
    print(i, dict_b[i])
for name, age in dict_b.items():
    print(name, age)

简写

1
2
3
4
5
# 字典简写 zip()
items = ['Fruit', 'Book', 'Other']
prices = [10, 45, 23]
dict_c = {k: v for k, v in zip(items, prices)}
print(dict_c)

■（七）： 元组tuple()

构造

tuple()【构造一个元组】

1
2
3
4
5
6
7
# 相当于一个常量的列表
# 元组 不可变序列 tuple()
tuple_a = ('Hello', 'world', 11)
tuple_b = tuple(('Hello', 'world', 11))
# 只包含一个元素的元组必须加上逗号
tuple_c = ('HelloWorld', )
tuple_d = ()

长度

len()【求长度】

1
2
# len()
print(len((20, 'helloworld', 3.14)))

遍历

1
2
3
# 元组遍历
for i in tuple_a:
    print(i)

■（八）： 集合set()

构造

{}

set()【构造一个集合】

1
2
3
4
5
6
7
8
9
10
# 集合 无值字典 无序
set_a = {'Hello', 'world', 11, 11, 11}
print(set_a) # 键只能有一个
set_b = set(range(6))
print(set_b)
set_c = set([1, 1, 2, 2, 3, 10])
print(set_c)
set_d = set('Python')
print(set_d)
set_e = set()

从属判断

in not in

1
2
# in  not in
print(11 in set_a)

长度

len()【求长度】

1
2
# len()
print(len({10, 20, 30}))

增删

add()【集合增加单个元素】

update()【集合增加多个元素】

remove()【删除指定元素，越界报错】

discard()【删除指定元素，越界不报错】

pop()【删除随机元素】

clear()【删除集合所有内容】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 增加 add() update()
set_a.add(True)
print(set_a)
set_a.update(['new', 'set'])
set_a.update({'what'})
print(set_a)
# 减少 remove() discard() pop() clear()
set_a.remove('what') # 删除指定元素，越界报错
print(set_a)
set_a.discard('new') # 删除指定元素，越界不报错
print(set_a)
set_a.pop() # 删除随机元素
print(set_a)
set_a.clear() # 删除集合所有内容
print(set_a)

集合关系

issubset()【判断是否被包含】

issuperset()【判断是否包含】

isdisjoint()【判断是否不包含】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 集合的无序性
# 无序相等
set_f = {10, 20, 30, 40}
set_g = {20, 40, 10, 30}
print(set_f == set_g)
# 子集
set_h = {10, 20, 30, 40, 50, 60}
set_i = {10, 20, 30, 40}
set_j = {10, 20, 100}
set_k = (60, 70, 80)
print(set_i.issubset(set_h))
print(set_j.issubset(set_h))
# 父集
print(set_h.issuperset(set_i))
print(set_h.issuperset(set_j))
# 交集（离集）
print(set_i.isdisjoint(set_k))

交并补

intersection()【求交集】

union()【求并集】

difference()【求差集】

symmetric_difference()【求并集 - 交集】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 集合数学操作
set_l = {10, 20, 30, 40, 50, 60}
set_m = {40, 50, 60, 70, 80}
# 求交集
print(set_l.intersection(set_m))
print(set_l & set_m)
# 求并集
print(set_l.union(set_m))
print(set_l | set_m)
# 求差集
print(set_l.difference(set_m))
print(set_l - set_m)
# 对称差集（除交集外范围）
print(set_l.symmetric_difference(set_m))
print(set_l ^ set_m)

简写

1
2
# 集合简写
set_n = {i for i in range(10)}

■（九）： 字符串处理

字符串的驻留机制

1
2
3
4
5
6
7
# 字符串的驻留机制
str_a = 'Python'
str_b = "Python"
str_c = '''Python'''
print(id(str_a))
print(id(str_b))
print(id(str_c))

字符串查询

index()【查找子串第一次出现的位置，越界报错】

rindex()【查找子串最后一次出现的位置，越界报错】

find()【查找子串第一次出现的位置，越界输-1】

rfind()【查找子串最后一次出现的位置，越界输-1】

endswith()【判断字符串是否以指定字符结尾】

1
2
3
4
5
6
7
# 字符串查询 index() rindex() find() rfind() endswith()
str_d = '字符串查询字符串查询'
print(str_d.index('串查')) # index() 查找子串第一次出现的位置，越界报错
print(str_d.rindex('串查')) # rindex() 查找子串最后一次出现的位置，越界报错
print(str_d.find('串查')) # find() 查找子串第一次出现的位置，越界输-1
print(str_d.rfind('串查')) # rfind() 查找子串最后一次出现的位置，越界输-1
print('demo_15.py'.endswith('.py'))

大小写

upper()【全转大写】

lower()【全转小写】

swapcase()【全部反转】

captilize()【第一个首字母大写，其余小写】

title()【所有单词第一个首字母大写，其余小写】

1
2
3
4
5
6
7
# 大小写更改 upper() lower() swapcase() captilize() title()
str_e = 'helloWorld hello'
print(str_e.upper()) # 全转大写
print(str_e.lower()) # 全转小写
print(str_e.swapcase()) # 全部反转
print(str_e.capitalize()) # 第一个首字母大写，其余小写
print(str_e.title()) # 所有单词第一个首字母大写，其余小写

对齐

center()【居中对齐】

ljust()【左对齐】

rjust()【右对齐】

zfill()【以0对齐】

1
2
3
4
5
6
7
# 对齐 center() ljust() rjust() zfill()
str_f = 'helloWorld'
print(str_f.center(30, '.')) # 居中对齐
print(str_f.ljust(30, '.')) # 左对齐
print(str_f.rjust(30, '.')) # 右对齐
print(str_f.zfill(30)) # 以0对齐
print(str_f.zfill(10)) # 如果设定宽度小于原字符长，则会失效

拆分

split()【通过拆分符拆分】

rsplit()【通过拆分符从右侧开始拆分】

1
2
3
4
5
6
7
8
# 拆分 split() rsplit()
str_g = 'hello/world/hello'
list_g1 = str_g.split(sep='/') # 通过拆分符拆分
print(list_g1)
list_g2 = str_g.split(sep='/', maxsplit=1) # 限制最大拆分数
print(list_g2)
list_g3 = str_g.rsplit(sep='/', maxsplit=1) # 从右侧开始拆分
print(list_g3)

替换与合并

replace()【替换字符串】

join()【用字符串合并列表】

1
2
3
4
5
6
7
# 替换和合并 replace() join()
str_l = 'helloWorldWorldWorld'
print(str_l.replace('World', 'Earth')) # 替换字符串
print(str_l.replace('World', 'Earth', 2)) # 限制最大替换次数
list_l = ['hello', 'world', 'python']
print('/'.join(list_l)) # 用字符串合并列表
print('/'.join('hello')) # 合并每一个字符

形态判断

isidentifier()【是否使用合法标识符】

isspace()【是否全是空格】

isalpha()【是否全是字母】

isdecimal()【是否全是十进制数字】

isnumeric()【是否全是数字】

isalnum()【是否全是字母或数字】

1
2
3
4
5
6
7
8
9
10
11
12
# 判断 isidentifier() isspace() isalpha() isdecimal() isnumeric() isalnum()
str_k1 = 'helloWorld'
str_k2 = '112233'
str_k3 = '      '
str_k4 = '%&|'
str_k5 = '0b00010000'
print(str_k4.isidentifier()) # 是否使用合法标识符
print(str_k3.isspace()) # 是否全是空格
print(str_k1.isalpha()) # 是否全是字母
print(str_k5.isdecimal()) # 是否全是十进制数字
print(str_k2.isnumeric()) # 是否全是数字
print(str_k1.isalnum()) # 是否全是字母或数字

切片

[::]

1
2
3
4
5
# 切片
str_m = 'hello,World'
print(str_m[2:8:1])
print(str_m[::2])
print(str_m[::-1])

格式化

%s %i %f % {}

format()【格式化】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 格式化
# %格式符 %s字符串 %i整数 %f浮点数
str_n1 = '姓名：%s，年龄：%i，分数：%f'
print(str_n1 % ('张三', 18, 59.5))
# {0}格式符
str_n2 = '姓名：{0}，年龄：{1}，分数：{2}'
print(str_n2.format('张三', 18, 59.5))
# {}格式符
name = '张三'
age = 18
score = 59.5
str_n3 = f'姓名：{name}，年龄：{age}，分数：{score}'
print(str_n3)
# %占位符
print('%10s' % 'str') # 使对象占10位
print('%.2f' % 3.1415926) # 使浮点数保留两位小数
print('%10.2f' % 3.1415926) # 同时保持宽度和精度
print('{0:.3}'.format(3.1415926)) # 保留三位有效数字
print('{0:.3f}'.format(3.1415926)) # 保留三位小数

编解码

encode()【编码】

decode()【解码】

1
2
3
4
5
6
7
8
# 编码
str_o = '编码解码'
print(str_o.encode(encoding='GBK'))
print(str_o.encode(encoding='UTF-8'))
# 解码
print(str_o.encode(encoding='GBK').decode(encoding='GBK'))
print(str_o.encode(encoding='UTF-8').decode(encoding='UTF-8'))

■（十）： 函数

构造

def return

1
2
3
4
5
6
7
8
9
# 函数
def func_1(if_a, if_b): # 形参 函数定义处
    c = if_a + if_b
    return c
#
print(func_1(15, 20)) # 实参 函数调用处
print(func_1(if_a=15, if_b=20)) # 关键字实参

# 形参定义规范int->i float->f bool->b str->s

形参改变实参值值不变

1
2
3
4
5
6
7
8
9
10
11
# 形参改变实参值值不变
# 形参改变实参地址值改变
def func_2(i_a, l_b):
    i_a = 100
    l_b.append(10)
    print(i_a, l_b)
    return
int_a = 11
list_b = [22, 33, 44]
func_2(int_a, list_b)
print(int_a, list_b)

返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 返回值
# 函数可以没有返回值，也可以有多个返回值
# 函数没有返回值时 return 可以不写
def func_3(i_a):
    print(i_a)
# 函数返回多个值时结果为元组
def func_4(l_num):
    odd = []
    eve = []
    for i in l_num:
        if i % 2 == 1:
            odd.append(i)
        else:
            eve.append(i)
    return odd, eve
#
print(func_4([44, 25, 17, 8, 49, 50, 55]))

函数的参数定义

位置参数：传参时依次列入

关键字参数：传参时按关键字列入

函数定义形参类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 函数定义形参类型
# （一）定义默认值形参：空
def fun_a(a, b = 10):
    print(a, b)
fun_a(20)

# （二）定义关键字形参：*
def fun_b(*a, b = 10):
    print(a, b)
fun_b(10, 20, b=20)

# （三）定义可变位置形参：*
def fun_c(*a):
    print(a)
fun_c(10, 20, 30)

# （四）定义可变关键字形参：**
def fun_d(**a):
    print(a)
fun_d(a=10, b=20)
def fun_d2(a, *, b): # *后的参数只能以关键字进行传递
    print(a, b)
fun_d2(10, b=20)

函数调用实参类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 函数调用实参类型
# （一）使用位置实参：空
def fun_e(a, b):
    print(a, b)
fun_e(10, 20)

# （二）使用关键字实参：空
def fun_f(a, b):
    print(a, b)
fun_f(a=10, b=20)

# （三）序列元组及字典键转化为位置实参：*
def fun_g(a, b):
    print(a, b)
fun_g(*[10, 20])
fun_g(*(10, 20))
fun_g(*{'a': 10, 'b': 20}) # 输出a b

# （四）字典值转化为位置实参：**
def fun_h(a, b):
    print(a, b)
fun_h(**{'a': 10, 'b': 20}) # 输出10 20

变量的作用域

1
2
3
4
5
6
7
8
9
10
# 变量的作用域
# 局部变量：只能在函数内定义使用的变量，只有当局部变量使用global声明才能成为全局变量
# 全局变量：函数外定义的变量，可作用于函数内外
def fun_a():
    a = 10 # 局部变量
    global b
    b = 15 # 全局变量
c = 20 # 全局变量
fun_a()
print(b)

递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 递归函数
# 在函数体中调用函数本身
def fun_b(n): # 计算阶乘
    if n == 1:
        return 1
    else:
        return n * fun_b(n - 1)
    # n * (n-1) * ((n-1)-1) * (((n-1)-1)-1) ...
#
print(fun_b(6))

# 斐波那契数列：前两项为1和1，之后为前两数之和
# 1 2 3 4 5 6 7 # 序数
# 1 1 2 3 5 8 13 # 斐波那契数
def fun_c(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fun_c(n - 1) + fun_c(n - 2)
#
print(fun_c(10))

■（十一）： 错误与异常

错误与异常处理机制

try【可疑代码】

except【异常情况】

else【无异常情况】

finally【无论有没有异常都会执行】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 错误与异常处理机制
# try: except:
# 输入except 在输入Error 就会出现所有异常的代码提示
try: # 可疑代码
    int_a = int(input('请输入被除数'))
    int_b = int(input('请输入除数'))
    res = int_a / int_b
except ZeroDivisionError: # 0为除数错误
    print('除数不得为0')
except ValueError: # 非数字输入错误
    print('输入不是数字')
except BaseException as bug: # 特殊可命名问题
    print('错误', bug)
else: # 无异常情况
    print('商为', res)
finally: # 无论有没有异常都会执行
    print('结束计算')

Traceback模块

1
2
3
4
5
6
# Traceback 模块 可以输出内建错误 用于记录程序日志
import traceback
try:
    print(1 / 0)
except:
    traceback.print_exc()

■（十二）： 类

类的创建

class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 类
class Student:
    # 类属性
    place = '中国' 
    # 构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 实例方法
    def student_a(self):
        print('helloWorld' + self.name)
    # 静态方法
    @staticmethod
    def student_b():
        print('helloWorldStatic')
    # 类方法
    @classmethod
    def student_c(cls):
        print('helloWorldClass')

类的定义

类属性

1
2
# 类属性
    place = '中国' # 直接写在类里的变量称为类属性

构造方法

1
2
3
4
5
6
# 构造方法
    # 在对象被创建时调用一次
    # 至少要包含一个默认self参数
    def __init__(self, name, age):
        self.name = name # self.name是实例属性，进行了赋值操作
        self.age = age

实例方法

1
2
3
4
5
6
# 实例方法
    # 可通过对象来直接调用：student_1.student_a()
    # 也可通过类来调用，但需要传入对象来充当self：Student.student_a(student_1)
    # 至少要包含一个默认self参数
    def student_a(self): # 在类里定义的def叫实例方法，在外的叫函数
        print('helloWorld' + self.name)

静态方法

1
2
3
4
5
6
7
# 静态方法
    # 可通过对象来直接调用：student_1.student_b()
    # 也可通过类来调用：Student.student_b(student_1)
    # 采用@staticmethod修饰
    @staticmethod
    def student_b():
        print('helloWorldStatic')

类方法

1
2
3
4
5
6
7
# 类方法
    # 可通过类来直接调用： Student.student_c()
    # 至少要包含一个默认cls参数
    # 采用@classmethod修饰
    @classmethod
    def student_c(cls):
        print('helloWorldClass')

对象

对象创建

1
2
# 对象创建
student_1 = Student('张三', 20)

使用对象实例方法

1
2
# 使用对象方法
student_1.student_a()

使用类方法

1
2
# 调用类方法
Student.student_a(student_1) # self

类属性的对象化

1
2
3
4
5
6
7
8
# 类属性调用
print(student_1.place) # '中国' |类默认为'中国'
Student.native_place = '日本' # 修改类默认值
print(student_1.place) # '日本' |为经定义的对象使用类默认值
student_1.native_place = '英国' # 修改对象类属性
print(student_1.place) # '英国' |对象修改为'英国'
Student.native_place = '日本' # 修改类默认值
print(student_1.place) # '英国' |定义后的对象不使用类默认值

动态绑定属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
# 动态绑定属性和方法
# 动态绑定属性
# 即为类动态创建一个新的临时类属性
student_2 = Student('李四', 30)
student_2.gender = '女'
print(student_1.name, student_1.age)
print(student_2.name, student_2.age, student_2.gender)
# 动态绑定方法
# 即为类动态创建一个新的临时类方法
def student_d():
    print('helloWorldOut')
student_1.student_d = student_d
student_1.student_d()

面向对象的三大特征

封装

1
2
3
4
5
6
7
8
9
10
11
12
# 封装：提高程序的安全性，将属性和方法包装到类对象中，在方法内部操作属性，在对象外部调用方法
# 设置属性私有：在前面使用'__'
class Student:
    def __init__(self, name, age):
        self.name = name # 公有属性
        self.__age = age # 私有属性
    def stu_a(self):
        print(self.__age)
#
stu_1 = Student('张三', 20)
stu_1.stu_a() # 私有属性能通过方法调用
print(stu_1._Student__age) # 私有属性外部调用

继承

继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 继承：如果一个类没有继承任何类，则默认继承object
# 定义子类时必须在构造函数中调用父类的构造函数
class Human(object):
    def __init__(self, name):
        self.name = name
    def info(self):
        print(self.name)
#
class Person1(Human):
    def __init__(self, name, age):
        Human.__init__(self, name) # 继承父类的构造方法
        self.age = age
#
per_1 = Person1('张三', 20)
per_1.info() # 调用父类方法
多继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 多继承
class Person2(Human):
    def __init__(self, name, id):
        Human.__init__(self, name) # 继承父类的构造方法
        self.id = id
#
class Teacher(Person1, Person2):
    def __init__(self, name, age, id, teacherID):
        Person1.__init__(self, name, age) # 继承父类的构造方法
        Person2.__init__(self, name, id) # 继承父类的构造方法
        self.teacherID = teacherID
#
tea_1 = Teacher('李四', 25, '001', '10001')
tea_1.info() # 调用爷类方法
方法重载
1
2
3
4
5
6
7
8
9
10
11
# 方法重写
class Person3(Human):
    def __init__(self, name, id):
        Human.__init__(self, name) # 继承父类的构造方法
        self.id = id
    def info(self):
        super().info() # 调用父类未重载版本的方法
        print(self.name, self.id)
#
per3_1 = Person3('王五', '10010')
per3_1.info()
object类
1
# object类是所有类的祖先类

多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 多态：一个方法可以在多个类中调用
class Animal(object):
    def eat(self):
        print('动物吃东西')
class Dog(Animal):
    def eat(self):
        print('狗吃肉')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Human(object):
    def eat(self):
        print('人吃饭')
def what2Eat(obj):
    obj.eat()
what2Eat(Dog())
cat = Cat()
what2Eat(cat)
what2Eat(Human())

特殊属性和方法

1
2
3
4
5
6
print(dir(object))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__',
# '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
# '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__',
# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
# '__sizeof__', '__str__', '__subclasshook__']

特殊属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Cl_a:
    pass
class Cl_b:
    pass
class Cl_c(Cl_a, Cl_b):
    def __init__(self, name, age):
        self.name = name
        self.age = age
obj_1 = Cl_c('name', 20)
print(obj_1.__dict__) # __dict__用于传递包含所有类属性的字典
print(obj_1.__class__) # __class__用于传递对象属于的类型
print(Cl_c.__bases__) # __bases__用于传递包含类的父类的元组
print(Cl_c.__mro__) # __mro__用于传递包含类的所有层级父类的元组
print(Cl_a.__subclasses__()) # __subclasses__用于传递包含类的子类的列表

特殊方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 传参过程：创建空对象时调用类 -> 类通过__new__方法构造self -> 类通过__init__方法构造对象 -> 对象传给刚创建的空对象
class Cl_d:
    def __new__(cls, *args, **kwargs): # 创建函数，用于创建self和对象
        print('id', id(cls))
        obj = super().__new__(cls)
        return obj
    def __init__(self, name): # 构造函数，用于创建对象并赋值
        self.name = name
    def __add__(self, other): # 加号重载允许两个对象相加
        return self.name + other.name
    def __len__(self): # 长度重载允许计算长度
        return len(self.name)
cl_d1 = Cl_d('张三')
cl_d2 = Cl_d('李四')
print(cl_d1 + cl_d2)
print(len(cl_d1))

类的浅拷贝和深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
# 变量拷贝引用
import copy
# 类的浅拷贝和深拷贝
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk

浅拷贝

copy().copy()【浅拷贝】

1
2
3
4
5
6
7
8
# 浅拷贝：对象的子对象内容不拷贝
cpu1 = CPU()
disk1 = Disk()
computer1 = Computer(cpu1, disk1)
computer2 = copy.copy(computer1)
print(computer1, computer1.cpu, computer1.disk) # 8100 A400 8640
print(computer2, computer2.cpu, computer2.disk) # CAF0 A400 8640
# 只拷贝了Computer类对象,子对象CPU类和Disk类不拷贝

深拷贝

copy().deepcopy()【浅拷贝】

1
2
3
4
5
6
7
8
# 深拷贝：全部拷贝
cpu2 = CPU()
disk2 = Disk()
computer3 = Computer(cpu2, disk2)
computer4 = copy.deepcopy(computer1)
print(computer3, computer3.cpu, computer3.disk) # 7430 0700 7400
print(computer4, computer4.cpu, computer4.disk) # F310 F430 F4C0
# 不仅拷贝了Computer类对象,还拷贝子对象CPU类和Disk类

■（十三）： 模块

构造

1
2
3
4
5
6
7
8
# 模块Modules
# 一个.py文件就是一个模块
# 模块里可以包含函数、语句、类、类定义
# 以下代码写在demo_14b.py中:
def add(a, b):
    return a + b
def div(a, b):
    return a / b

引用

import【引用模块】

1
2
3
4
5
6
7
8
# 四种import引用模块
import demo_14b # 直接引入，使用demo_14b.xxx调用
import demo_15b as b15 #　间接引入，直接使用b15.xxx调用
from math import pi # 区域引入，只能使用pi
from time import * # 作用域强转，模块能像内置函数一样调用，比如time()
#
print(demo_14b.add(10, 20))
print(demo_14b.div(10, 20))

使用内建模块

1
2
# 引用library内建方法
import Lib.json.encoder

直接与间接调用模块

1
2
3
4
5
6
# 直接调用模块
import math
# 间接调用模块
from math import pi
print('{:.10}'.format(math.e)) # 直接调用模块内数据或方法
print('{:.10}'.format(pi)) # 间接调用模块内数据或方法

获取模块内所有方法检索

1
print(dir(math)) # 通过dir来获取模块内的所有方法

以主程序形式执行

1
2
3
4
5
6
7
8
# 以下代码写在demo_15b.py中:
def add(a, b):
    return a + b
def div(a, b):
    return a / b
# 输入main回车
if __name__ == '__main__': # 只有当运行此被引用的模块时，才会调用
    print(add(10, 20))
1
2
3
4
# 以下代码写在demo_15.py中:
# 以主程序形式执行
import demo_15b
print(demo_15b.add(40, 50))

第三方模块

下载pip工具

1
https://pypi.org/project/pip/#files

环境变量设置

1
2
我的电脑->属性->高级系统设置->环境变量->用户变量Path编辑->添加新变量
python的安装地址

安装pip工具

1
2
pip的下载文件夹解压->搜索栏cmd->
python setup.py install

环境变量设置

1
2
我的电脑->属性->高级系统设置->环境变量->用户变量Path编辑->添加新变量
python的安装地址/Scripts

使用pip来在线下载卸载第三方模块（慢的一批）（还他妈容易闪退）

1
2
3
win+r->cmd->
下载：pip install 模块名
卸载：pip uninstall 模块名

使用pip+镜像来在线下载第三方模块（快的一批）

1
2
3
4
5
6
7
win+r->cmd->
清华镜像：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 模块名
中科大镜像：pip install -i https://pypi.mirrors.ustc.edu.cn/simple 模块名
豆瓣镜像；pip install -i http://pypi.douban.com/simple 模块名
华中理工镜像：pip install -i http://pypi.hustunique.com 模块名
山东理工镜像：pip install -i http://pypi.sdutlinux.org 模块名
阿里云镜像：pip install -i http://mirrors.aliyun.com/pypi/simple 模块名

实在pip无能为力的模块可以直接下whl文件

1
2
3
4
常用模块wheel安装包下载地址（必须使用谷歌浏览器）
https://www.lfd.uci.edu/~gohlke/pythonlibs/
将下载好的whl文件放到C:\Users\user里
pip install 文件名.whl

常用第三方模块

视觉
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#图像pillow
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pillow

#视频moviepy
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple moviepy
#连带安装[moviepy/decorator/tqdm/requests/proglog/numpy/imageio/imageio-ffmpeg/pillow]

#计算机视觉库opencv-python
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade setuptools
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple opencv-python
#连带安装[opencv_python/numpy/Matplotlib/python_dateutil/kiwisolver/cycler/pillow/pyparsing/six]
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple opencv-contrib-python
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pytesseract

#计算机图形库pyopengl
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyopengl

#小海龟turtle
下载：[https://files.pythonhosted.org/packages/ff/f0/21a42e9e424d24bdd0e509d5ed3c7dfb8f47d962d9c044dba903b0b4a26f/turtle-0.0.2.tar.gz]
40行修改：[except (ValueError, ve):]
pip install -e 下好的小海龟文件夹路径turtle-0.0.2 -i https://pypi.tuna.tsinghua.edu.cn/simple
#连带安装[turtle/zope.interface/constantly/incremental/attrs/Automat/hyperlink/PyHamcrest/Twisted/PyYAML]
声音
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#声音PocketSphinx
https://www.lfd.uci.edu/~gohlke/pythonlibs/#pocketsphinx
教程https://www.bilibili.com/video/BV1hE411F747?p=3
#连带安装[sphinxbase/PocketSphinx]

#声音Speech_Recognition
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple SpeechRecognition

#声音Pyttsx3
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple Pyttsx3
#连带安装[pywin32/pypiwin32/comtypes/Pyttsx3/pythoncom/pywintypes/_win32sysloader]

#声音sapi
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple sapi
#连带安装[pycparser/cffi/winkerberos/cryptography/requests-kerberos/lxml/python-cern-sso-krb/fire/configparser/sapi]

#声音speechlib
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple comtypes

#录音pyaudio
https://www.lfd.uci.edu/~gohlke/pythonlibs/#pocketsphinx
教程https://www.bilibili.com/video/BV1yp4y1Q7jN?from=search&seid=11950388352880821570
应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#桌面应用PyQt
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyqt5
#连带安装[pyqt5/PyQt5-sip]
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyqt5-tools
#连带安装[pyqt5-tools/pyqt5-plugins/python-dotenv/click/qt5-tools/qt5-applications]
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyside2
#连带安装[shiboken2/pyside2/typing-extensions/colorama]

#桌面应用(不建议)wxPython
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple wxPython
#连带安装[wxPython/six/numpy/pillow]

#2D游戏pyGame
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyGame

#3D游戏pyglet
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyglet
数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#科学计算NumPy
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple NumPy

#科学计算SciPy
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple SciPy

#数据分析pandas
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas
#连带安装[pandas/pytz/python-dateutil/numpy/six]

#二维绘制Matplotlib
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple Matplotlib
#连带安装[matplotlib/pyparsing/python-dateutil/kiwisolver/pillow/cycler/numpy/six]

#Exel表格XlsxWriter
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple XlsxWriter

#Exel表格xlrd
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple xlrd

#Exel表格Openpyxl
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple Openpyxl
#连带安装[jdcal/et-xmlfile/Openpyxl]

#计时调度schedule
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple schedule

#交互文档JupyterNotebook
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple jupyter
#连带安装[ipython-genutils, traitlets, pyrsistent, wcwidth, tornado, pyzmq, parso, jupyter-core, jsonschema, webencodings, prompt-toolkit, pickleshare, packaging, nest-asyncio, nbformat, MarkupSafe, jupyter-client, jedi, backcall, async-generator, testpath, pywinpty, pandocfilters, nbclient, mistune, jupyterlab-pygments, jinja2, ipython, entrypoints, defusedxml, bleach, terminado, Send2Trash, prometheus-client, nbconvert, ipykernel, argon2-cffi, notebook, widgetsnbextension, qtpy, jupyterlab-widgets, qtconsole, jupyter-console, ipywidgets, jupyter]

#Jupyter插件
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple Jupyter Notebook extensions
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple flask
#连带安装[itsdangerous/flask]

#Jupyter插件安装器jupyter_contrib_nbextensions
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple jupyter_contrib_nbextensions 
#连带安装[jupyter-contrib-core, jupyter-nbextensions-configurator, jupyter-latex-envs, jupyter-highlight-selected-word, jupyter-contrib-nbextensions]
jupyter contrib nbextension install --user

#Jupyter插件安装器配置Jupyter Nbextensions Configurator
pip install jupyter_nbextensions_configurator
jupyter nbextensions_configurator enable --user
网络
1
2
3
4
5
6
#网络访问requests
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple requests
#连带安装[requests/chardet/idna/urllib3/certifi]

#网络自动化客户端selenium
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple selenium
机器学习
1
2
3
4
5
6
7
8
9
10
11
#机器学习Tensorflow
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple tensorflow
#连带安装[termcolor/tensorflow-estimator/google-pasta/h5py/protobuf/keras-preprocessing /wheel/opt-einsum/flatbuffers/astunparse/gast/tensorboard-plugin-wit/grpcio/absl-py /werkzeug/markdown/cachetools/pyasn1/pyasn1-modules/rsa/google-auth/oauthlib/requests-oauthlib/google-auth-oauthlib/tensorboard/tensorflow]

#机器学习scikit-learn
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple scikit-learn
#连带安装[threadpoolctl/joblib/scikit-learn]

#爬虫scrapy
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple scrapy
#连带安装[scrapy/目前安装失败]
工具
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#导出可执行文件PyInstaller
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple PyInstaller

#富文本输出rich
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple rich
#连带安装[rich/commonmark/pygments/colorama/typing-extensions]

#严格代码规范(vscode)Pylint
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pylint
#连带安装[pylint/lazy-object-proxy/wrapt/astroid/isort/toml/mccabe]

#操作控制pyautogui
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyautogui
#连带安装[pymsgbox/PyTweening/pyscreeze/pyrect/pygetwindow/pyperclip/mouseinfo/pyautogui]

出现输入pip指令没有反映的情况

1
2
我的电脑->属性->高级系统设置->环境变量->用户变量Path编辑->删除Windows商店变量
%USERPROFILE%\AppData\Local\Microsoft\WindowsApps

pip版本升级

1
2
3
4
5
#升级pip
win+r->cmd->
pip install -U pip
python -m ensurepip
python -m pip install --upgrade pip

■（十四）： 编码格式

编码格式

1
2
3
4
# 编码格式
# python解释器使用Unicode编码（内存）
# .py文件在磁盘上使用UTF-8存储（外存）
# encoding = gbk # 修改成gbk编码

■（十五）： 文件读写io

引用

1
2
# 文件读写IO（input&output）
import io

读写流程

open()【开启文件】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 读写文件流程：
# 打开或新建文件 -> 读写文件 -> 关闭文件
# open()创建文件对象
# 文件对象 = open(文件地址名 文件打开模式 编码)

# 读：
# 例：学习清单.txt：python wxpython Qt blender UE AE houdini nuke
# 绝对地址
# file_1 = open('D:/Users/user/Desktop/学习清单.txt', 'r')
# 相对地址
file_2 = open('学习清单.txt', 'r')
list_2 = file_2.readlines()[0].split(sep=' ')
for i in list_2:
    print(i, end='\t')
file_2.close()

文件打开模式

1
2
3
4
5
6
7
8
9
10
11
12
13
# 文件打开模式
# r：read    以只读打开文件，文件的指针在文件的开头
# w：write   以只写打开文件，文件不存在则创建，文件存在则覆盖，文件的指针在文件的开头
# a：add     以追加打开文件，文件不存在则创建，文件存在则追加，文件的指针在文件的结尾
# b：binary  以二进制打开文件，不能单独使用，需要同rb或wb一起使用
# +：以读写打开文件，不能单独使用，需要同a+一起使用

# 复制操作
png_1 = open('sima.png', 'rb')
png_2 = open('sima_2.png', 'wb')
png_2.write(png_1.read())
png_1.close()
png_2.close()

文件对象常用方法

读

read()【读全部】

readline()【读一行】

readlines()【读多行，将每一行作为一个列表元素】

1
2
3
4
5
6
# 读 read() readline() readlines()
file_3 = open('学习清单.txt', 'r')
print(file_3.read(20)) # 读取全部read(可读字符数)
print(file_3.readline()) # 读取一行
print(file_3.readlines()) # 读取多行，将每一行作为一个列表元素
file_3.close()

写

write()【写入】

writelines()【写入多个或列表】

1
2
3
4
5
6
# 写 write() writelines()
file_4 = open('txt_1.txt', 'a') # a/w
file_4.write('helloWorld\n') # 将字符串写入
list_3 = ['hello ', 'world ', 'python ', '\n']
file_4.writelines(list_3)
file_4.close()

指针

seek()【跳过字节】

tell()【指针当前位置】

1
2
3
4
5
6
# 指针 seek() tell()
file_5 = open('txt_1.txt', 'r')
file_5.seek(5) # 跳过5个字节再来读，中文占两个字节
print(file_5.read())
print(file_5.tell()) # 指针当前位置
file_5.close()

缓冲

flush()【保存】

close()【保存关闭】

1
2
3
4
5
6
# 缓冲 flush() close()
file_6 = open('txt_1.txt', 'a')
file_6.write('hello')
file_6.flush() # 保存
file_6.write('world')
file_6.close() # 保存关闭

with语句

构造

1
2
3
4
# with语句
# 自动上下文管理协议，用于析构，不需要手动close()
with open('txt_1.txt', 'r') as file:
    print(file.read())

使用

1
2
3
4
5
6
7
8
9
10
11
12
13
# 使用with处理的对象必须得有__enter__()和__exit__()方法
# __enter__()方法在with执行之前进入运行，__exit__()方法在with执行完毕退出后运行
# with适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作
class ContextMgr(object):
    def __enter__(self):
        print('__enter__()方法')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('__exit__()方法')
    def show(self):
        print('show方法')
with ContextMgr() as mgr:
    mgr.show()

活用

1
2
3
4
5
6
7
# 使用with进行复制并转格式
with open('sima.png', 'rb') as file:
    with open('simaCopy.gif', 'wb') as fileCopy:
        fileCopy.write(file.read())
with open('shitman.mp4', 'rb') as file:
    with open('shitman.mov', 'wb') as fileCopy:
        fileCopy.write(file.read())

■（十六）： 操作系统os

引用

1
2
# os 操作系统
import os

系统

system()【系统操作】

startfile()【直接调用资源文件】

1
2
3
4
5
# win + r 运行操作
# os.system('notepad.exe')
# os.system('calc.exe')
# 直接调用资源文件
# os.startfile('D:\\Document_Files\\Everything\\Everything.exe')

目录

getcwd()【获取代码当前路径】

listdir()【获取路径下的文件列表】

mkdir()【创建目录文件夹】

makedirs()【创建多级目录文件夹】

rmdir()【删除目录文件夹】

removedirs()【删除多级目录文件夹】

chdir()【设置当前代码路径】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# os模块相关函数
# getcwd() listdir() mkdir() makedirs() rmdir() removedirs() chdir()
print(os.getcwd()) # 代码当前路径
print(os.listdir('D:\\Users\\user\\Desktop')) # 路径下的文件列表
print(os.listdir('../PY_1')) # ../返回上一级
os.mkdir('dir_demo') # 创建目录文件夹
os.makedirs('dir_1/dir_2/dir_3') # 创建多级目录文件夹
# 创建套娃文件夹
str_1 = ''
list_1 = []
for i in range(10):
    str_1 = 'dir_' + str(i + 1)
    list_1.append(str_1)
str_2 = '/'.join(list_1)
os.makedirs('D:/Users/user/Desktop/' + str_2)
#
os.rmdir('D:/Users/user/Desktop/dir_1') # 删除目录文件夹
os.removedirs('D:/Users/user/Desktop/' + str_2) # 删除多级目录文件夹
os.chdir('E:\MyProjects\PythonProjects\PY_2') # 设置当前代码路径

路径

引用

1
2
# os.path
import os.path

路径

abspath()【获取绝对路径】

exists()【判断文件目录是否存在】

join()【用/将字符串地址拼接起来】

split()【用列表将字符串地址拆包】

splitext()【分离文件名与扩展名】

basename()【在地址中提取文件名】

dirname()【在地址中提取路径】

isdir()【判断是否是纯路径而不是文件地址】

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# abspath() exists() join() splitext() basename() dirname() isdir()
print(os.path.abspath('demo_18.py')) # 获取绝对路径
print(os.path.exists('demo_18.py')) # 判断文件目录是否存在
print(os.path.join('E:\MyProjects', 'PythonProjects', 'PY_1')) # 用/将字符串地址拼接起来
print(os.path.splitext('demo_18.py')) # 分离文件名与扩展名
print(os.path.basename('E:\MyProjects\PythonProjects\PY_1\demo_18.py')) # 在地址中提取文件名
print(os.path.dirname('E:\MyProjects\PythonProjects\PY_1\demo_18.py')) # 在地址中提取路径
print(os.path.isdir('E:\MyProjects\PythonProjects\PY_1')) # 判断是否是纯路径而不是文件地址
# 文件格式过滤
url_3 = '../PY_1'
list_2 = os.listdir(url_3)
list_3 = []
for i in list_2:
    if os.path.splitext(i)[1] == '.py':
        list_3.append(i)
print(list_3)

提取所有文件

walk()【提取所有文件】

1
2
3
4
5
6
7
8
9
# walk()
print(os.walk('../PY_1')) # 包含所有文件及地址的元组(路径，路径名列表，文件列表)
# print(dir(os.walk))
for dirpath, dirname, filename in os.walk('../PY_1/Directory_1'):
    print(dirpath)
    print(dirname)
    print(filename)
    for file in filename:
        print(os.path.abspath(os.path.join(dirpath, file)))

■（十七）：导出exe可执行文件

使用pyinstaller导出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
pyinstaller -F -i 图标地址 -n 导出名 --noconsole py文件.py


[-h帮助] [-v版本] [-D新建目录] [-F导出单一] [--specpath DIR] [-n NAME文件名]
[--noconsole无dos窗口]
[--add-data <SRC;DEST or SRC:DEST>]
[--add-binary <SRC;DEST or SRC:DEST>] [-p DIR]
[--hidden-import MODULENAME添加模块]
[--additional-hooks-dir HOOKSPATH]
[--runtime-hook RUNTIME_HOOKS] [--exclude-module EXCLUDES]
[--key KEY] [-d {all,imports,bootloader,noarchive}] [-s]
[--noupx] [--upx-exclude FILE] [-c] [-w]
[-i <FILE.ico or FILE.exe,ID or FILE.icns>图标]
[--version-file FILE] [-m <FILE or XML>] [-r RESOURCE]
[--uac-admin] [--uac-uiaccess] [--win-private-assemblies]
[--win-no-prefer-redirects]
[--osx-bundle-identifier BUNDLE_IDENTIFIER]
[--runtime-tmpdir PATH] [--bootloader-ignore-signals]
[--distpath DIR] [--workpath WORKPATH] [-y]
[--upx-dir UPX_DIR] [-a] [--clean] [--log-level LEVEL]
scriptname [scriptname ...]

optional arguments:
  -h, --help            显示这些帮助
  -v, --version         显示pyinstaller版本
  --distpath DIR        Where to put the bundled app (default: .\dist)
  --workpath WORKPATH   Where to put all the temporary work files, .log, .pyz
                        and etc. (default: .\build)
  -y, --noconfirm       Replace output directory (default:
                        SPECPATH\dist\SPECNAME) without asking for
                        confirmation
  --upx-dir UPX_DIR     Path to UPX utility (default: search the execution
                        path)
  -a, --ascii           Do not include unicode encoding support (default:
                        included if available)
  --clean               清除所有缓存
  --log-level LEVEL     Amount of detail in build-time console messages. LEVEL
                        may be one of TRACE, DEBUG, INFO, WARN, ERROR,
                        CRITICAL (default: INFO).

What to generate:
  -D, --onedir          Create a one-folder bundle containing an executable
                        (default)
  -F, --onefile         生成单一可执行文件
  --specpath DIR        Folder to store the generated spec file (default:
                        current directory)
  -n NAME, --name NAME  Name to assign to the bundled app and spec file
                        (default: first script's basename)

What to bundle, where to search:
  --add-data <SRC;DEST or SRC:DEST>
                        Additional non-binary files or folders to be added to
                        the executable. The path separator is platform
                        specific, ``os.pathsep`` (which is ``;`` on Windows
                        and ``:`` on most unix systems) is used. This option
                        can be used multiple times.
  --add-binary <SRC;DEST or SRC:DEST>
                        Additional binary files to be added to the executable.
                        See the ``--add-data`` option for more details. This
                        option can be used multiple times.
  -p DIR, --paths DIR   A path to search for imports (like using PYTHONPATH).
                        Multiple paths are allowed, separated by ';', or use
                        this option multiple times
  --hidden-import MODULENAME, --hiddenimport MODULENAME
                        Name an import not visible in the code of the
                        script(s). This option can be used multiple times.
  --additional-hooks-dir HOOKSPATH
                        An additional path to search for hooks. This option
                        can be used multiple times.
  --runtime-hook RUNTIME_HOOKS
                        Path to a custom runtime hook file. A runtime hook is
                        code that is bundled with the executable and is
                        executed before any other code or module to set up
                        special features of the runtime environment. This
                        option can be used multiple times.
  --exclude-module EXCLUDES
                        Optional module or package (the Python name, not the
                        path name) that will be ignored (as though it was not
                        found). This option can be used multiple times.
  --key KEY             The key used to encrypt Python bytecode.

How to generate:
  -d {all,imports,bootloader,noarchive}, --debug {all,imports,bootloader,noarchive}
                        Provide assistance with debugging a frozen
                        application. This argument may be provided multiple
                        times to select several of the following options.

                        - all: All three of the following options.

                        - imports: specify the -v option to the underlying
                          Python interpreter, causing it to print a message
                          each time a module is initialized, showing the
                          place (filename or built-in module) from which it
                          is loaded. See
                          https://docs.python.org/3/using/cmdline.html#id4.

                        - bootloader: tell the bootloader to issue progress
                          messages while initializing and starting the
                          bundled app. Used to diagnose problems with
                          missing imports.

                        - noarchive: instead of storing all frozen Python
                          source files as an archive inside the resulting
                          executable, store them as files in the resulting
                          output directory.

  -s, --strip           Apply a symbol-table strip to the executable and
                        shared libs (not recommended for Windows)
  --noupx               Do not use UPX even if it is available (works
                        differently between Windows and *nix)
  --upx-exclude FILE    Prevent a binary from being compressed when using upx.
                        This is typically used if upx corrupts certain
                        binaries during compression. FILE is the filename of
                        the binary without path. This option can be used
                        multiple times.

■（十八）代码文档 JupyterNotebook

  • 下载python后自带jupyter，但是还是得用pip安装一遍
  • 文档文件类型为.ipynb文件，vscode可兼容，通常使用网页
  • 在指定目录下cmd->jupyter notebook可以打开指定目录下的文档
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
选择模式 【网页：点选输入框外，行显示蓝色】
编辑模式 【网页：点选输入框内，行显示绿色】
------------------------------------
选择模式
------------------------------------
enter 【网页选择：进入编辑模式】
H 【快捷键检视】
A 【向上新建代码行】
B 【向下新建代码行】
X 【删除选择行】
Z 【撤销删除行】
M 【转换为markdown】
Y 【转换为代码块】
H 【搜索】
P 【命令热盒】
123456 【转换为md标题】
C 【复制】
shift + V 【向上粘贴】
V 【向下粘贴】
O 【隐藏输出】
L 【显示行标】
------------------------------------
编辑模式
------------------------------------
esc 【网页编辑：进入选择模式】
enter 【换行】
shift + enter 【执行并换行】
ctrl + enter 【执行】
ctrl + / 【切换注释】
ctrl + Z 【撤销】
ctrl + Y 【重做】
ctrl + shift + - 【从光标分裂代码行】