pyhton学习笔记
python
-字符串
-字符串内建函数
1.capitalize() 开头第一个字母大写
2.title() 单词首字母大写
3.upper() 全部转大写
4.lower() 全部转小写
5.返回位置find(‘ ’，start,end) rfind() lfind() rindex() lindex() replace('',count)
6.startwith() endwith() 返回值都是布尔型，用于判断
7.isalpha()是否字母 isdigit() 是否数字 isalnum() 是否是字母和数字组成
8.' '.join(), 为元素指定拼接的字符,并返回一个新的序列
9.截掉空格 lstrip() rstrip() strip()
10.startwith() endwith() 返回值都是布尔型，用于判断
-字符串切片
s1="hello world"
print(s1[-1:-6:-1])#倒叙输出，左闭右开，步长-1
print(s1[:-5]) #当前到-5位置，左闭右开，步长默认为1
print(s1[::-3])#步长-3，倒叙输出，
print(s1[2:3]) #
输出：
dlrow
hello
dooe
l
- 编码与解码
编码encode() 解码decode()
编码格式：gbk 中文 gb2312 简体中文 Unicode utf-8
s1="上课了，注意听讲"
s2=s1.encode("utf-8")
print(s1.encode("utf-8"))
print(s2.decode("utf-8"))
- 列表
函数：
1.append() 末尾追加
2.extend() 类似列表合并
3.insert (位置，内容)插入
4.remove(e) 删除第一次出现的e,返回none，如果没找到要删除的元素e,报异常
5.pop() 弹栈 删除末尾的元素,返回被删除的元素，默认删除最后一个，也可以指定index删除
6.clear() 清空列表
7.del list_name[index]
8.reverse() 翻转可以改变列表结构，反向输出
9.enumerate() 同时实现输出索引值和元素内容
10.sum(列表名) 求和
11.str()转字符串 int()转整形 list()转列表 类型转换
12.sort(key=str.lower,reverse=False) 排序，默认false升序排列，True降序排列
13.sorted(列表名) 排序，不改变原来列表顺序
14.min(列表名) 最小值
15.max(列表名) 最大值
16.len(列表名) 列表长度
17.+ l1=[1,2,3] l2=[4,5] l1+l2=[1,2,3,4,5]
18.* l1=[1,2,3] l1*2=[1,2,3,1,2,3]
- 元组
属性： 1.关键字：tuple
2.只能获取，不能增加，减少，或修改
3.元组中只有一个元素时，需要在后面加“,”,否则默认不是元组类型
符号： 1.+ t1=(1,2,3) t2=(4,5,6) t1+t2=(1,2,3,4,5,6)
2.* t1=(1,2,3)*2==>t1(1,2,3,1,2,3)
3.is
4.not
5.in
6.not in
函数： 1.index(e)返回元素e在元组中的下标
2.count (e)返回元素e在元组中出现的次数
3.turple()元组转换
4.max() 获取最大值
5.min() 获取最小值
6.sum() 求和
7.len() 元组长度
8.sorted() 排序，返回值的结果是列表，可用tuple()转换
9.tuple() 转换为元组
通过切片实现对元组值得修改:
tuple1=('张三','李四','王五')
position=tuple1.index("李四")
tuple1=tuple1[:position]+tuple1[position+1:]
print(tuple1)
- 装包与拆包
a,b=t1 #ValueError: too many values to unpack (expected 2)
print(a,b)
x,y,z=(6,) #ValueError: not enough values to unpack (expected 3, got 1)
print(x,y,z)
t1=(4,7,3)
a,b,c=t1
print(a,b,c)
a=t1
print(a)
变量个数与元组个数不一致
t1=(2,5,3,6,9,8)
a,_,*c=t1
print(a,c,_) #2 [3, 6, 9, 8] 5
*a,b,c=t1
print(a,b,c) #[2, 5, 3, 6] 9 8
t1=(9,)
a,*b=t1;
print(a,b) #*b 表示未知个数0~n; 结果：9 []
手动拆包
y=[4,8,9]
print(*y)
print(*['A','b','C'])
- 字典
dict={key:value}
函数： 1.dict() 转字典
2.items() 键值对
3.values() 值
4.keys() 键
5.get(key,["自定义"]) 根据key返回value，找不到时，返回自定义
6.del dict[key] 删除元素
7.update() 字典合并操作 result=dict1.update(dict2)
8.fromkeys(seq,[default])--->将seq转成字典的形式，如果没有指定默认的value则用None
new_dict=dict.fromkeys(list1)---->{'aa':none,'bb':none,'cc':none}
----->如果指定default,则用default替代none这个value值
new_dict=dict.fromkeys(list,10)---->{'aa':10,'bb':10,'cc':10}
字典的删除：
1.del diction[key] key不存在或输入错误的情况下会有keyerror
2.pop(key,[,default]) 根据key删除字典中的键值对，只要删除成功返回键值对的值Value
pop的默认值，往往是在删除的时候没有找到对应的key,则返回default默认值
3.popitem() 随机删除字典中的键值对（一般从末尾删除元素）
4.clear() 同列表的删除
符号：in 用于字典操作 用于判断元素有没有在key中出现
特点：key值唯一，当key存在时，同名key，新值覆盖旧值，若key不存在，则增加新元素
字典的创建：1.zip()映射函数创建字典
2.给定关键字创建
3.fromkeys()方法创建值为空的字典
4.直接创建并初始化diction={key：value}
字典推导式：
import random
randomdict={i:random.randint(10,100) for i in range(1,5)}
print("生成字典：",randomdict)
列表转字典 前提：列表中的元素都要成对出现
dict1=dict([('ddsa',2),(2,4)])
print(dict1)
元组转字典
tuple1=((1,2),(3,4),(5,6))
print(dict(tuple1))
- 集合
作用：去重
声明集合：set
s1=set() #创建空集合，只能使用set()
s2={元素1，元素2，元素3}
增删改查：
add(e) 添加元素e,一次添加一个
update() 添加多个
remove(e) 存在删除e元素，不存在报错keyError
pop() 随机删除(一般删除第一个元素)
clear() 清空
discard(e) 删除指定的元素e
符号操作：in 判断某元素是否在集合中
set1==set2 判断set1是否和set2相等
- 求差集 set1-set2,,前提set1的元素要多于set2==difference()
& 交集==intersection()
| 并集 union() 联合
对称差集：^ 找两个列表里面不同的元素 set1^set2==(set1|set2)-(set1 & set2)
s1.difference_update(s2) 找出s1与s2的差集，并赋值给s1
s1.intersection_update(s2) 找出s1与s2的交集，并赋值给s1
s1.union_update(s2) 找出s1与s2的并集，并赋值给s1
s1.symmetric_difference_update() 对称差集并赋值
应用场景：去除重复项
list1={1,2,3,1,5,43,6,58,5,2,4,12,53,2}
ss=["lucy","jack"]
s1=set(list1)
print(s1)
s1.add("渣渣")
print(s1)
s1.update(ss)
print(s1)
s1.remove("lucy")
print(s1)
s1.pop()
print(s1)
num=int(input("请输入一个数字："))
s1.discard(num)
print(s1)
s1.clear()
print(s1)
import random
set1=set()
for i in range(10):
ran=random.randint(1,20)
set1.add(ran)
print(set1,len(set1))
set1={1,2,3,4,5}
set2={1,2,3,4,5,6}
print(set2-set1) #求差集
print(set2.difference(set1)) #求差集
print(set1&set2) #求交集
print(set1.intersection(set2)) #求交集
print(set1|set2) #求并集
print(set1.union(set2)) #求并集
- 可变与不可变
不可变：对象所指向内存中的值是不可改变的
可变的类型：int str float 元组tuple
isinstance(object,type) 判断obj是否为type类型 eg.isinstance(1,int) 判断1是不是int类型
int1=5
print(id(int1))
int1=6
print(id(int1))
可变：对象所指的内存中的值是可以改变的
可变类型：字典dict 列表list 集合set
dict1={1:1,2:"3"}
print(dict1,id(dict1))
dict1.pop(1)
print(dict1,id(dict1))
-全局变量与局部变量
全局变量与局部变量
全局变量如果是不可变类型，在函数中进行修改，需要添加关键子global,如果是可变类型，在函数中就不用添加global
- 内部函数
- 闭包
----内部函数
特点：
1.可以访问外部函数的变量
2.内部函数可以修改外部函数的可变类型的变量：list1
3.内部函数修改全局的不可变变量时，需要在内部函数声明global 变量名
内部函数修改外部函数的不可变的变量时，需要在内部函数中声明：nonlocal 变量名
4.locals() 查看本地变量有哪些，以字典的形式输出
globals() 查看全局变量有哪些，以字典的形式输出（注意里面会有一些系统的键值对）
----闭包
条件：1.外部函数中定义了内部函数
2.外部函数是有返回值
3.返回的值是：内部函数名
4.内部函数引用了外部函数的变量
格式：def 外部函数():
…
def 内部函数():
…
return
能够保存返回闭包时的状态（外层函数变量）
def func(a,b):
c=10
def inner_func():
s=a+b+c
print('相加之后的结果是',s)
return inner_func
ifunc=func(2,8)
ifunc1=func(3,6)
def func(a,b):
c=10
def inner_func():
s=a+b+c
print('相加之后的结果',s)
return inner_func
ifunc=func(2,8)
ifunc()
ifunc=func(3,6)
ifunc()
- 装饰器
特点：1.函数作为参数给了另外一个参数
2.要有闭包的特点
定义装饰器(decorate)
def decoreate(func):
a=100
print('hello')
def wrapper():
print('1111111111110')
func()
print('222222222',a)
return wrapper
使用装饰器
执行过程：1.house被装饰函数 //
2.将被装饰函数作为参数传给装饰器decorate
3.执行decorate函数
如果装饰器是多层的，调用顺序，离被装饰函数近的会被先调用
@decoreate
def house():
print('我是毛坯房……')
house()
-----登录校验
import time
def decorate(func):
def wrapper():
func()
print('正在校验中……')
time.sleep(2)
print('校验完毕……')
# 调用原函数
return wrapper
@decorateb
def login():
act=input("账号:")
pwd=input("密码:")
login()
装饰带参函数
import time
def add(func):
def add_all(*args,**kwargs):
print('正在验证登录状态……')
time.sleep(2)
print('验证通过')
func(*args,**kwargs)
print('加入成功')
return add_all
@add
def shop(num,k=10):
print('向入购物车添加{}件{}商品'.format(num,k))
shop(10)
多层装饰器
import time
def shop1(func):
def paint():
func()
print('正在准备中……')
time.sleep(2)
print('准备完毕……')
print('刷漆')
return paint
def shop2(func):
def background():
func()
print('正在准备中……')
time.sleep(2)
print('准备完毕……')
print('铺地板')
return background
@shop2
@shop1
def build():
print('装修房子')
build()
装饰器带参(默认就是三层，最外层负责接收装饰器传来的参数)
import time
def outer(a):#第一层，a属于outer内部的变量
print(a)
def decorate(func):#第二层
def wrapper(*args,**kwargs):#第三层
func(*args)
print('正在准备中……')
time.sleep(2)
print('准备完毕')
print('……'+'铺地砖')
return wrapper
return decorate
def shop(func):
def background(*args,**kwargs):
func(*args)
print('正在准备中……')
time.sleep(2)
print('准备完毕')
print("……"+"刷漆")
return background
@shop
@outer(10)
def built(time):
print('我是{}日期拿到的钥匙，房子是毛坯房……'.format(time))
built('2020-11-30')
案例：付款登录
import time
islogin=False
def login():
username=input('请输入用户名：')
password=input("请输入密码：")
if username=='admin' and password=='123456':
return True
else:
return False
def login_require(func):
def wrapper(*args,**kwargs):
global islogin
print('正在进行付款操作……')
if islogin:
func(*args,**kwargs)
else:
print('用户没有登录，不能付款')
islogin=login()
print('result:',islogin)
return wrapper
@login_require
def pay(money):
print('付款金额{}'.format(money))
print('付款中……')
time.sleep(2)
print('付款完成')
num=input("请输入付款金额:")
pay(num)#第一次付款，islogin=False
pay(num)#第二次付款，islogon=true
- 匿名函数
匿名函数：简化函数定义
格式：lambda 参数1，参数2 ：运算
s=lambda a,b:a+b
result=s(1,2)
print(result)
匿名函数作为参数
def func(x,y,func):
print(x,y)
print(func)
s=func(x,y)
print(s)
func(1,2,lambda a,b:a+b)#调用func
匿名函数与内置函数的结合使用
#max sorted zip……
list1=[1,2,3,4,5,6]
max_num=max(list1)
print(max_num)
list2=[{'a':10,'b':20},{'a':3,'b':8},{'a':9,'b':15},{'a':25,'b':36}]
m=max(list2,key=lambda x:x['a'])
print(m['a'])
print(m)
------------map
list3=[3,4,6,7,8,9,10,12]
result=map(lambda x:x+2,list3)
print(result)#<map object at 0x000002B2ECE13358>
print(list(result))#将map转化成list[5, 6, 8, 9, 10, 11, 12, 14]
for index, i in enumerate(list3):
list[index]=i+2
list3=[3,4,6,7,8,9,10,12]
func=lambda x:x if x%2==0 else x+1
result=func(5)
print(result)
result=map(lambda x:x if x%2==0 else x+1,list3)
print(list(result))
**********reduce(): 对列表中的元素进行加减乘除运算的函数
from functools import reduce
list1=[3,6,5,8,9,4,5]
result=reduce(lambda x,y:x+y,list1)
print(result)
- filter测试减法过滤
list1=[9,8,7,5,4,6,3]
result=filter(lambda x:x>4 and x<7,list1)
print(list(result))
list2=[{'name':'lili','age':18},
{'name':'jack','age':26},
{'name':'lucy','age':15},
{'name':'tom','age':21}]
result=filter(lambda x:x['age']>15,list2)
print(list(result))
- 递归函数
def sum(n): #1~n
if n==0:
return 0
else:
return n+sum(n-1)
result=sum(15)
print(result)
- 作用域
作用域LEGB（函数找变量的规则寻找顺序）
L：local 本地 局部变量
E：enclosing 嵌套
G：Global 全局
B：built-in 内置的
- 文件操作
函数：open(filename,[,mode])
mode:打开模式 参数：读：r ,rb ,r+ ,rb+ ；写：w ,wb ,w+ ,wb+ ；追加：a ,ab ,a+ ,ab+
参数：r:只读 rb:以二进制打开文件，采用只读模式，一般用于非文本，如图片，声音等
r+:可以读取，也可以写入新的内容覆盖原有内容 rb+:二进制打开，采用读写模式，用于非文本，如图片，声音等
w:只写 wb:以二进制打开，采用只写，一般用于非文本，如图片，声音等
w+:打开文件，清空原有内容，使文件变为空文件，对该文件有读写权限 wb+:以二进制打开，采用读写模式，一般用于非文本，如图片，声音等
a：追加模式打开，若文件以存在，文件指针放文件末尾（新内容会被写在已有内容之后），否则创新文件用于写入
ab:二进制打开,采用追加,若文件存在, 文件指针放文件末尾（新内容会被写在已有内容之后），否则创建新文件用于写入
a+:以读写模式打开,若文件存在, 文件指针放文件末尾（新内容会被写在已有内容之后），否则创建新文件用于读写
ab+:以二进制格式打开,采用追加,若文件存在, 文件指针放文件末尾（新内容会被写在已有内容之后），否则创建新文件用于读写
方法：
close(): 关闭已经打开的文件
flush():若写入内容后，不想立即关掉文件，可以调用flush()方法，用于把缓冲区的内容写入到文件中，保证了数据全部写入到磁盘中
write(str):写入字符串，自动换行
writelines(list):向文件中写入字符串列表，不添加换行符
read([size]):读取文件，size用于指定读取字符的个数
readline():按行读取文件
readlines():读取全部行,返回结果存在一个列表中
seek(offset[,whence]):offset 用于指定移动的字符个数，whence,用于从什么位置开始计算，0 从头开始，1当前位置开始，2 文件末尾开始，默认为0
使用with语句打开文件：在处理文件时，无论是否抛出异常，都能保证with语句执行结束后,关闭已经打开的文件。
函数：access(path,accessmode):获取对文件是否具有指定的访问权限（读取/写入/执行权限），若有权限则返回1，否则返回0
值：R_OK（读取），W_OK（写入），X_OK(执行)，或F_OK（存在）
chomd(path,mode):修改path指定的文件访问权限
remove(path):删除path指定的文件路径
rename(src,dst):将文件或目录src重命名为dst 注意：重命名目录时，只能修改最后一级的目录名称，否则会报异常 stat(path):返回path指定得文件的信息 返回的对象的常用属性：st_mode：保护模式 st_ino：索引号 st_nlink:硬连接号（被连接的数目） ` st_size:文件大小，单位字节 st_mtime:最后一次修改的时间
st_dev:设备名 st_uid:用户ID st_gid:组ID st_atime:最后一次访问时间
st_ctime:最后一次状态变化时间（系统不同，返回结果也不同，windows返回文件
创建时间）
startfile(path[,operation]):使用关联的应用程序打开path指定的文件
- 打开文件
with open(filename,[,mode],[,enconding]) as file: #file是用于保存处理结果的变量
pass
stream=open ('./str.py','r',encoding='UTF-8')
stream=stream.read()
print(stream)
- 写入文件
#写入文件
#案例:创建并打开记录蚂蚁庄园的动态文件
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','w')
print('\n 即将显示…… \n')
向空文件中写入内容
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','w',encoding='UTF-8')
file.write("你使用了1张加速卡，小鸡进食速度加快了\n")
print('\n 写入动态成功……\n')
file.close() #写入内容后一定要注意调用close()方法，否则写入内容不会出现在文件中。
#追加动态信息到文件中
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','a',encoding='UTF-8')
file.write("\nTom 的小鸡在你的庄园中待了15分钟，吃了6g饲料，被你赶走了。\n")
print('\n 写入动态成功……\n')
file.close()
#writelines()的用法
list1=["你的小鸡中毒了\n","Tom的小鸡又来抢食了\n","你的小鸡下蛋了\n"]
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','a',encoding='UTF-8')
file.writelines(list1)
print('\n 写入动态成功……\n')
file.close()
- 读取文件
#读取文件
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','r',encoding='UTF-8')
result=file.read()
print(result)
file.close()
#按行读取
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','r',encoding='UTF-8')
while True:
result = file.readline()
print(result)
if result=='':
break
file.close()
# 读取全部行
print("\n","="*10,"蚂蚁庄园动态","="*10)
file=open('message.txt','r',encoding='UTF-8')
result=file.readlines()
print(result)
file.close()
- 删除文件
#删除文件：文件存在—》删除，不存在—》报异常，因此删除前，应先判断文件是否存在
import os
os.remove('t1.txt')
print('删除成功')
- 重命名文件
import os
src='./message.txt'
dst='./message1.txt'
if os.path.exists(src):
os.rename(src,dst)
print('文件命名完毕')
else:
print('文件不存在！')
- 获取文件信息
import os
fileinfo=os.stat('./str.py')
print('文件完整路径：',os.path.abspath('str.py'))
#输出文本的基本信息
print('索引号：',fileinfo.st_ino)
print('设备名：',fileinfo.st_dev)
print('文件大小：',fileinfo.st_size,'字节')
print('最后一次访问时间：',fileinfo.st_atime)
print('最后一次修改时间：',fileinfo.st_mtime)
print('最后一次状态变化时间',fileinfo.st_ctime)
- 格式化文件基本信息
import os
def formatTime(longtime):
'''
格式化日期时间的函数
longtime:要格式化的时间
'''
import time
return time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(longtime))
def formatByte(number):
'''
格式化文件的函数
num:要格式化的字节数
'''
for(scale,label) in [(1024*1024*1024,'GB'),(1024*1024,'MB'),(1024,'KB')]:
if number>=scale: #如果文件大小大于或等于1KB
return "%.2f %s" %(number*1.0/scale,label)
elif number==1: #如果文件大小为1字节
return '1字节'
else: #处理小于1KB的情况
byte="%.2f"%(number or 0)
#去掉结尾的.00，并且加上单位‘字节’
return (byte[:-3] if byte.endswith('.00') else byte)+"字节"
if __name__=='__main__':
fileinfo = os.stat('./str.py')
print('文件完整路径：', os.path.abspath('str.py'))
# 输出文本的基本信息
print('索引号：', fileinfo.st_ino)
print('设备名：', fileinfo.st_dev)
print('文件大小：', formatByte(fileinfo.st_size))
print('最后一次访问时间：', formatTime(fileinfo.st_atime))
print('最后一次修改时间：', formatTime(fileinfo.st_mtime))
print('最后一次状态变化时间', formatTime(fileinfo.st_ctime))
- 目录操作（os模块）
函数：
getcwd():返回当前工作目录
listdir(path):返回指定路径下的文件和目录信息
mkdir(path[,mode]):创建目录
makedirs(path1/path2……[,mode]):创建多级目录
rmdir(path):删除目录（只能删除空目录，并且被删除目录不能存在子目录）
rmtree(path):删除非空目录(import shutil) eg.shutil.rmtree(path)
removedirs(path)：删除多级目录(只会删除指定的目录，若被指定目录下存在子目录或文件，子目录或文件并不会
被删除)
chdir(path):把path设置成当前工作目录
walk(top[,topdown][,onerror][,followlinks]):遍历目录树，该方法返回一个元组，包括所有路径名，所有目录列表和文件列表3个元素
walk:只在Unix和Windows系统中有效；top:用于指定要遍历内容的根目录
topdown:遍历的循序，True(先遍历根目录)，False(先遍历最后一个子集目录)，默认是True
onerror:指定错误处理的方式，默认忽略，若不想忽略，可以指定一个错误处理函数
followlinks:walk()函数不会向下转换成解析到目录的符号连接，将该参数值设置为True,
表示用于指定在支持的系统上访问由符号链接指向的目录。
os.path模块
abspath(path):用于获取文件或目录的绝对路径
exists(path):用于判断目录或者文件是否存在，如果存在则返回True,否则返回False
join(path,name):将目录与目录或者文件名拼接起来
注意：1.路径也可以用字符串进行拼接，但更推崇用join(),因为join可以适用不同操作系统路径的拼接
2.路径拼接并不会检测被拼接路径是否存在
3.若被拼接path中存在多个路径，那么拼接结果以拼接路径的最后一个路径为准
splitext():分离文件名和扩展名
basename(path):从一个目录中提取文件名
dirname(path):从一个路径中提取文件路径，不包括文件名
isdir(path):用于判断是否为有效路径
getsize():获取文件大小
isabs():判断是否是绝对路径
isfile():判断是否是文件
# 方法：
os.path.dirname(_file_)----->获取当前文件所在路径
os.path.abspath('filename')---->获取指定文件filename所在路径的绝对路径
os.path.getcwd()----->获取当前文件所在文件夹的路径
os.path.isfile(path)---->判断目标文件路径是否是文件
os.path.isfile(path)---->判断目标文件路径是否是目录，返回值是布尔类型
os.path.split(path)----->切割路径并放在元组中
# 获取当前文件所在文件夹的路径
path=os.path.dirname(__file__)
print(path) #D:/lesson/python
获取str.py的路径
path=os.path.abspath('str.py')
print('绝对路径：',path) #绝对路径： D:\lesson\python\str.py
result=os.path
#获取当前文件所在文件夹的路径
path=os.getcwd()
print(path)
#判断目标文件路径是否是文件
r=os.path.isfile(path)
print(r)
#判断目标文件路径是否是目录，返回值是布尔类型
r=os.path.isdir(os.getcwd())
print(r)
path=os.path.abspath('str.py')
print(path)
result=os.path.split(path)
print(result)
#获取当前文件所在文件夹下,所有文件的文件名
list_name = []
path=os.path.dirname(__file__)
for filename in os.listdir(path):
# print(filename)
list_name.append(filename)
print(list_name)
print(list_name[3])
file_path=os.path.join(path,list_name[4])
print(file_path)
with open(file_path,'r',encoding='utf-8') as file:
while True:
result = file.readline()
print(result,end="")
if result=='':
break
print('结束')
- 创建目录
#### - 创建目录
# 创建目录：在当前工作目录下创建目录（先判断，创建的目录是否存在，若不存在，再创建）
import os
path=os.getcwd()
path=os.path.join(path,'demo')
if not os.path.exists(path):
os.mkdir(path)
print("目录创建成功")
else:
print("该目录已存在")
#创建多级目录(在当前工作目录下，创建多级目录)
#方法1：直接通过makedirs创建
import os
path=os.getcwd()
path=os.path.join(path,'demo1/test/txt')
if not os.path.exists(path):
os.makedirs(path)
print("目录创建成功")
#方法2：通过对mkdir()的递归调用
import os
def mkdir(path):
if not os.path.isdir(path):
mkdir(os.path.split(path)[0])
else:
return
os.mkdir(path)
path=os.getcwd()
path=os.path.join(path,"test/dd/tt/100")
mkdir(path)
print('创建成功')
- 删除目录
#删除目录(案例：删除当前工作目录下的空demo1目录)
#删除空目录
import os
path=os.getcwd()
path=os.path.join(path,'demo1')
os.rmdir(path)
print('删除成功')
#删除多级目录(目录中可以存在目录，但不能存在文件，一个神奇的删除方式，反正我是没想通，好困)
import os
path=os.getcwd()
path=os.path.join(path,'asd/test/tt')
os.removedirs(path)
print('删除成功')
#删除多级非空目录
import shutil
import os
path=os.getcwd()
path=os.path.join(path,'demo')
shutil.rmtree(path)
print("删除成功")
- 重命名目录
import os
src='./test'
dst='./test1'
if os.path.exists(src):
os.rename(src,dst)
print('目录重命名完毕')
else:
print('目录不存在！')
- 遍历目录
遍历工作目录
import os
path=os.getcwd()
tuples=os.walk(path)
for tuple1 in tuples:
print(tuple1)
遍历指定目录
import os
path_root="D:/lesson"
print('[',path_root,']目录下包括的文件和目录：')
for root,dirs,files in os.walk(path_root,topdown=True):
for name in dirs:
print("@",os.path.join(root,name))
for name in files:
print("$",os.path.join(root,name))
- 生成器
yield 相当于return ,返回的是一个`生成器对象
生成器方法：
next():获取下一个元素
send(value):向每次生成器调用中传值 ：第一次调用send(None)
list2=[1,2,3,6,9,10]
g=(i+2 for i in list2)
list1=[]
for i in range(len(list2)):
c=g.__next__()
list1.append(c)
print(list1)
#创建生成器：
get=((i+2)/3 for i in range(10))
while True:
try:
print(next(get))
except:
print("没有更多元素了")
break
#菲波那切
def fw(length):
a,b=0,1
n=0
while n<length:
yield b
a, b = b, a + b
n+=1
g=fw(8)
while True:
try:
print(next(g))
except:
print("生成完毕……")
break
- 迭代器
迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
特点： 迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。
迭代器对象从第一个元素开始访问，直到所有的元素被访问结束。
迭代器只能往前不会后退。
注意：生成器是可迭代的，也是迭代器
list是可迭代的，但不是迭代器
iter(Iteration):将可迭代对象转换成迭代器
- 面向对象
特点：在python中，模块是代码组织的一种方式，把功能相近或者类放到一个文件中，一个文件（.py）就是一个模块（module）
模块名就是文件名`去掉后缀
1.自定义模块
2.使用系统一些模块
导入模块：
1.import 模块名
模块名.变量 模块名.函数 模块名.类
2.from 模块名 import 变量 | 函数 | 类
在代码中可以直接使用变量.函数，类
3.from 模块名 import *
该模块中的所有内容
但是如果想要限制获取的内容，可以在模块中使用__all__=[使用*可以访问到的内容]
4.无论是important 还是from的形式，都会将模块中的内容进行加载
如果不希望其进行调用，就会用到__name__
在自己模块里面__name__=main
在其他文件中__name__=文件名
- 第三方库
- matplotlib库
拓展导入字体:
方法1：windows和linux设置字体的方式(用不了)
font={'family':'MicroSoft YaHei',
'weight':'bold',
'size':'larger'}
matplotlib.rc("font",**font)
matplotlib.rc("font",family='MicriSoft Yahei',weight="bold")
方法2：from matplotlib import font_manager导入字体设置模块
my_font=font_manager.FontProperties(fname="path") path:字体存在的路径
from matplotlib import pyplot as plt 导入matplotlib库
方法：plt.figure(figsize=(n1,n2),dpi) 设置图片大小
散点图: plt.scatter(x,y,[label="name",color=" ",linestyle="😕--",linewidth=""])
条形图：plt.bar(x,y,width)竖着 plt.barh(x,y,height)
折线图: plt.plot(x,y,[label="name",color=" ",linestyle="😕--",linewidth=""]) 绘制图片 label: 线名 linewidth:线条粗细
直方图：plt.hist(list,分组数)：
plt.xticks(x,[str],rotation=90) 设置x轴坐标 可通过列表的步长(间隔取值),rotation:旋转角度,str:字符串用于替换变量x,作为轴的横坐标
plt.yticks() 设置y轴坐标 字符串字体设置使用font_manager模块
plt.savefig(path) 保存图片
plt.show() 输出展示图片
plt.title() 图表标题
plt.xlabel() x轴描述信息
plt.ylabel() y轴描述信息
plt.grid([alpha=0.4,linestyle="😕--"],linewidth="") 绘制网格 alpha:网格透明度,0-1
plt.legend([prop=fonttype],[loc="upper left"]) 图例 prop:字体 loc: 图例出现的位置
from matplotlib import pyplot as plt# 导入
x=range(2,26,2)# x点
y=[15,13,14.5,17,20,25,26,26,27,22,18,15]# y点
plt.figure(figsize=(20,8),dpi=80)#设置图片大小
plt.plot(x,y)#绘制图片
# plt.xticks(range(2,26))# 设置x轴的刻度
# plt.yticks(range(2,26))# 设置y轴的刻度
plt.savefig("./t1.png")#保存图片
plt.show()
实例(折线图) :列表a表示10点到11点的每一分钟的气温,如何绘制折线图观察每一分钟气温的变化情况?
a=[random.randint(20,35) for i in range(120)]
from matplotlib import pyplot as plt
import random
from matplotlib import font_manager
my_font=font_manager.FontProperties(fname="./font/Dengl.ttf")#设置字体
y=[random.randint(20,35) for i in range(60)]
x=range(0,60)
y_1=[random.randint(2,15) for i in range(60)]
x_1=range(0,60)
plt.figure(figsize=(20,8),dpi=80)
plt.plot(x,y,label="白天",linestyle=":")
plt.plot(x_1,y_1,label="晚上")
_x=['10点{}分'.format(i) for i in range(60)]#生成字符串替换列表
plt.xticks(list(x)[::3],_x[::3],rotation=45,fontproperties=my_font)
plt.title("10点到12点的每一分钟的气温",fontproperties=my_font)
plt.ylabel("温度",fontproperties=my_font)
plt.xlabel("时间",fontproperties=my_font)
plt.grid(alpha=0.4)#绘制网格
plt.legend(prop=my_font,loc="upper left")
plt.show()
print(y)#现实每一分钟的温度
print(list(x)[::3])
# 实例(散点图)：
from matplotlib import pyplot as plt
import random
from matplotlib import font_manager
my_font=font_manager.FontProperties(fname="./font/Dengl.ttf")
y=[random.randint(16,19) for i in range(15)]
x=range(0,15)
_y=[random .randint(16,33) for i in range(15)]
_x=range(32,47)
x_1=list(x)+list(_x)
_x_label=['3月{}号'.format(i) for i in x]0
_x_label+=['10月{}号'.format(i) for i in _x]
plt.figure(figsize=(20,8),dpi=80)
plt.xticks(x_1,_x_label,rotation=45,fontproperties=my_font)
plt.scatter(x,y,label="3月份",linestyle=":")
plt.scatter(_x,_y,label="10月份",linestyle=":")
plt.title("10点到12点的每一分钟的气温",fontproperties=my_font)
plt.ylabel("温度",fontproperties=my_font)
plt.xlabel("时间",fontproperties=my_font)
plt.grid(alpha=0.4)#绘制网格
plt.legend(prop=my_font,loc="upper left")
plt.show()
#实例(直方图)：
from matplotlib import pyplot as plt
from matplotlib import font_manager
my_font=font_manager.FontProperties(fname="./font/Dengl.ttf")
a=["战狼2","速度与激情","功夫瑜伽","西游降魔片","最后的勇士"]
b=[65,74,32,66,52]
plt.figure(figsize=(20,8),dpi=80)
plt.barh(range(len(a)),b,height=0.3,color="blue")
plt.yticks(range(5),a,fontproperties=my_font)
# plt.grid(alpha=0.4)
plt.show()
3列表a中视频上映三天的播放次数
from matplotlib import pyplot as plt
from matplotlib import font_manager
my_font=font_manager.FontProperties(fname="./font/Dengl.ttf")
a=["战狼2","速度与激情","功夫瑜伽","西游降魔片","最后的勇士"]
b_16=[15476,312,556,778,664]
b_15=[13456,421,562,456,987]
b_14=[14565,522,456,122,333]
bar_width=0.2
x_14=list(range(len(a)))
x_15=[i+bar_width for i in x_14]
x_16=[i+bar_width*2 for i in x_14]
plt.bar(range(len(a)),b_14,width=bar_width,label="9月14")
plt.bar(x_15,b_15,width=bar_width,label="9月15号")
plt.bar(x_16,b_16,width=bar_width,label="9月16号")
plt.xticks(x_15,a,fontproperties=my_font)
plt.legend(prop=my_font)
plt.show()
- numpy库
导入 import numpy as np
方法:
np.array([],dtype='int8') dtype 用于指定数组的数据类型
np.round(array,num) 保留小数
np.loadtxt(frame,dtype,delimiter=None,skiprows=0,usecols=None,unpack=False) 读取本地数据
参数：
frame:文件，字符串或产生器，可以是.gz或bz2压缩文件
dtype:数据类型，可选，csv的字符串以什么数据类型读入数组中，默认np.float
delimiter:分割字符串，默认时任何空格，改为逗号
skiprows: 跳过前x行，一般跳过第一行表头
usecols:读取指定的列，索引，元组类型
unpack:如果为True,读入属性分别写入不同数组变量，False读入数据只写入一个数组变量，默认False
numpy 中的nan:
1.两个nan是不相等的 nan(NAN,Nan):not a number表示不是一个数字，当读取本地文件为float的时候，如果有 缺失，就会出现nan,当做了一个不合适的计算时也会出现
2.np.nan!=np.nan
3.np.count_nonzero(t!=t):利用nan不相等的特性判断nan的个数
4.由于np.nan!=np.nan 通过np.isnan(a)l来判断，返回bool类型，比如将nan替换为0----》t[np.isnan(t)]=0
5.nan和任何值计算都为nan
创建数组：
a=np.array([1,2,3,4,5])
b=np.array(range(1,6))
c=np.arange(1,6)
np.arange的用法：arange([start,] stop[,step],dtype=None)
np.zeros((3,4)):创建一个全为0的数组
np.ones((3,4)):创建一个全是1的数组
np.eye(3):创建一个对角线为1的正方形数组（方阵）
拼接数组：
np.vstack((t1,t2)): 竖直拼接
np.hstack(t1,t2):水平拼接
np.argmax(t,axis=0):获取最大值的位置
np.argmin(t,axis=1):获取最小值的位置
np.arange的用法：arange([start,] stop[,step],dtype=None)
np.zeros((3,4)):创建一个全为0的数组
np.ones((3,4)):创建一个全是1的数组
np.eye(3):创建一个对角线为1的正方形数组（方阵）
np.count_nonzero(t1):计算数组中不为0的元素个数
np.isnan(t1):
数组数值修改：
np.where(t<10,5,6): 三元运算符，t<10 ? 5:6
clip(10,18):小于10的替换成10，大于18的替换成18 （nan浮点型）
transpose() / .T / swapaxes(1,0) 转置
astype() 用于修改数组的数据类型
shape()查看数组的形状
reshape 修改数组的维度
数组的计算：
求和：np.sum(t1,[axis=0|1]):当axis=0时求得是数组中每一列的和，当axis=1时，计算数组中每一行的和
均值：np.mean(a,axis=None) 受离群点的影响较大
中值：np.median(t,axis=None)
最大值：t.max(axis=None)
最小值：t.min(axis=None)
极值：np.ptp(t,axis=None)
标准差：t.std(axis=None):标准差是一组数据平均值分散程度的一种度量，一个较大的标准差，带表大部分数值和其平均值之间差异较大;一个较小的标准差，代表这些数值较接近平均值反映出的数据波动稳定情况，越大表示波动越大，越不稳定。
默认返回多维数组的全部统计结果,如果指定axis则返回一个当前轴上的结果
numpy生成随机数数组：
.rand(d0,d1,..dn) :创建d0-dn维度的均匀分布的随机数组，浮点数，范围从0-1
.randn(d0,d1,..dn):创建d0-dn维度的标准正态分布随机数，浮点数，平均数0，标准差1
.randint(low,high,(shape)):从给定上下限范围选取随机整数，范围是low,high,形状是shape
.uniform(low,high,(size)):产生具有均匀分布的数组，low起始值，high结束值，size形状
.normal(loc,scale,(size)):从正太分布中随机抽取样本，分布中心是loc(概率分布的均值)，标准差是scale，形状是size
.seed(s): 随机数种子，s是给定的种子值，因为计算机生成的是伪随机数，所以通过设定相同的随机数种子，可以每次生成相同的随机数
import numpy as np
t1=np.array([1.0235,2.3456,3.5678])
# print(t1.dtype)
# t1=t1.astype('float')
# print(t1.dtype)
t1=np.round(t1,2)
s=t1.shape
print(s)
数组切片和索引
import numpy as np
path='./test.csv'
t1=np.loadtxt(path,delimiter=",",dtype="int")
print("本地文件：text.csv\n",t1)
print("*"*30)
print("t1[行，列]")
print('****行操作：')
print("取第四行t1[3]：\n",t1[3])
print("取不连续的多行t1[[0,3]]：\n",t1[[0,3]])
print("取连续的多行t1[::2]：\n",t1[::2])
print('\n****列操作：')
print("取第n列:t1[:,0]\n",t1[:,0])
print("取某行某列:4行4列t1[3,3]\n",t1[3,3])
print("取连续的列t1[:,2:]\n",t1[:,2:])
print("取不连续的多列0列和2列t1[:,[0,2]]：\n",t1[:,[0,2]])
print("取多行多列：\n 取第三行到第五行，第2列到第4列\n",t1[2:5,1:4])
print("取多个不相邻的点\n",t1[[0,2,2],[0,1,3]])
print("转置之后:\n",t1.T)
print("t1小于10",t1<10)
print("数组的替换：\n")
t1[t1<10]=3
print("t1中t1小于10的令其等于3，t1[t1<10]=3\n",t1)
t2=np.where(t1<10,2,8)
print("t1中小于10的令其等于2，大于10的令其等于8\n",t2)
t1=t1.clip(10,18)
print("将t1中小于等于10的替换成10，大于等于18的替换成18\n",t1)
print("数组的拼接:\n")
print("数组的行列交换：\n行交换：t[[1,2],:]=t[[2,1],:]\n列交换：t[:,[0,2]]=t[:,[2,0]]")
import numpy as np
t1=np.zeros((3,4)) #生成一个3行4列数值为0的数组
t2=np.ones((3,4)) #生成一个3行4列数值为1的数组
t3=np.eye(5) #生成一个对角线为1的正方形方阵
print(t1,'\n',t2)
print(t3)
import numpy as np
np.random.seed(3)
t=np.random.randint(0,20,(3,4))
num=np.count_nonzero(t)
t1=np.isnan(t)
print(t)
print("数组中是否含有nan:\n",t1)
print("数组中不为0的元素个数",num)
print("数组t行的总和：",np.sum(t,axis=1))
print("数组t列的总和：",np.sum(t,axis=0))
给nan赋值
import numpy as np
t1=np.arange(12).reshape(3,4).astype("float")
t1[1,2:]=np.nan
def fill_ndarray(t1):
for i in range(t1.shape[1]): #遍历每一列
temp_col=t1[:,i] #当前的一列
nan_num=np.count_nonzero(temp_col!=temp_col)
if nan_num!=0: #不为0，说明当前这一列中有nan
temp_not_nan_col=temp_col[temp_col==temp_col] #当前一列不为nan的array
#选中当前为nan的位置，把值赋值为不为nan的均值
temp_col[np.isnan(temp_col)]=temp_not_nan_col.mean()
return t1
if __name__=='__main__':
t1=np.arange(12).reshape((3,4)).astype("float")
t1[1,2:]=np.nan
print(t1)
t1=fill_ndarray(t1)
print(t1)
- Pandas库
导入：import pandas as pd
拓展：import string
方法：string.ascill_uppercase[i] 0<i<26 可取到对应的26个大写字母
方法：pd.Series(list,index=""):列表创建
t.index: 获取Series中的索引（可变量，可迭代,可用list强制转换成列表，进行切片操作）
t.values:获取Series中值，与index具有同样的属性
where(t<10,n): t<10的替换成n
clip(10,18):小于10的替换成10，大于18的替换成18 （nan浮点型）
argmax(t,axis=0):获取最大值的位置
argmin(t,axis=1):获取最小值的位置
pd.read_csv(path):读取path路径下的文件
pd .read_sql(sql,connect):sql语句 connect链接
pd.DataFrame(数组对象，index,columns): 当axis(index)=0时，行索引，当axis(index)=1时，列索引
Series的创建：带标签的数组（键，值）
字典推导式创建：
a={string.ascii_uppercase[i]:i for i in range(10)}
列表创建：pd.Series(list,[index=""]) 可为list指定等长的索引index，默认时数字
Series的切片：
dataFrame的操作：
df.shape:行数,列数
df.dtypes:列数据类型
df.ndim:数据维度
df.columns:列索引
df.values:对象,二维ndarray数组
df.head(3) #显示头部几行,默认5行
df.tail(3) #显示末尾几行,默认5行
df.info() #相关信息概览
df.describe() #快速综合统计接过:计数,均值,标准差,最大值,四分位数,最小值
df.sort_values(by="字段",ascending):按照某字段排序 ascending=True升序排列,false降序排列
loc("行字段"，"列字段"): 可获取数据和赋值改变数据
iloc(行控制，列控制)： 可获取数据和赋值改变数据 ：在前不包含后面的 ：在后包含前面的 eg:[:2,1:] 第2行之前，第1列之后，前不包，后包
pandas(str) 字符串操作：
cat:实现元素级的字符串操作，可指定分割符
contains:返回表示各字符串是否含有指定模式的布尔数组
count:模式出现的次数
endswith,startswith:相当于对各个元素执行x.endswith(pattern)或x.startswith(pattern)
findall:计算各字符串的模式列表
get:获取各元素的第i个字符
join:根据指定的分隔符将Series中各元素的字符串连接起来
len
计算各字符串的长度
lower,upper: 转换大小写，相当于各元素执行x.lower()或x.upper()
match: 根据指定的正则表达式对各元素执行re.match
pad: 在字符串的左边，右边或左右两边添加空白符
center: 相当于pad(side='both')
repeat: 重复值，例如，s.str.repeat(3) 相当于对各个字符串执行x*3
replace:用于指定字符串替换找到的模式
slice: 对Series中的个各个字符串进行子串截取
split: 根据分隔符或正则表达式对字符串进行拆分
strip,rstrip,lstrip: 去除空白符,包括换行符,相当于对各个元素执行x.strip(),x.strip(),x.lstrip()
缺失数据的处理：
pd.isnull() / pd.notnull() 判断是否为NaN
方法1：dropna(axis=0,how='any',inplace=False) 删除NaN所在的行列
方法2：t.fillna(t.mean(),t.fillna(t.median()),t.fillna(0)) 填充数据
处理为0的数据：
t[[t==0]=np.nan] 注意：并不是每次为0的数据都需要处理，计算平均值等情况，nan不参与计算，但0会
import pandas as pd
import string
#直接创建Series
t=pd.Series([1,2,3,4,5,6],index=list("abcdef"))
print(t)
字典推导式创建Series
a={string.ascii_uppercase[i]:i for i in range(26)}
a=pd.Series(a)
print(a)
#列表创建Series
list1=[1,2,3,5,6,6,6,8,9,545,5,8]
b=pd.Series(list1,index=[string.ascii_条uppercase[i] for i in range(len(list1))])
print(b)
df=pd.read_csv('./dog.csv')
print(df)
DataFrame的应用
import pandas as pd
import numpy as np
##通过numpy创建：
t1=pd.DataFrame(np.arange(12).reshape(3,4))
print("默认索引：\n",t1)
t2=pd.DataFrame(np.arange(12).reshape(3,4),index=list("abc"),columns=list("wxyz"))
print("指定索引：\n",t2)
##通过字典创建：
d1={"name":["张三","李四","王五"],"age":[20,36,18],"tel":["13991426365","18456792012","13991426629"]}
t3=pd.DataFrame(d1)
print(t3)
print(type(t3))
#pandas之取行或者取列操作
import pandas as pd
df=pd.read_csv("./dog.csv")
df=df.sort_values(by="Count_AnimalName",ascending=False)#按照Count_AnimalName降序排列 默认ascending=True为升序排列
print('输出文件所有信息:\n',df)
print("*"*35)
print('输出文件前20条信息(取行操作):\n',df[:20])
print('输出文件某字段的全部信息（取列操作）:\n',df["Row_Labels"])
#pandas之loc操作
import pandas as pd
import numpy as np
t3=pd.DataFrame(np.arange(12).reshape(3,4),index=list("abc"),columns=list("WXYZ"))
print("全部信息：\n",t3)
print("loc某行某列：\n",t3.loc["b","X"])#某行某列
print("loc某行多列：\n",t3.loc["b",["Y","Z","W"]])#某行多列
print("loc某列多行：\n",t3.loc[["a","b","c"],"W"])#某列多行
print("当前列：\n",t3.loc[:,"Y"])#当前列
print("当前行：\n",t3.loc['c',:])#当前行
print("多行多列：\n",t3.loc["a":"c","X":"Z"])#多行多列
#pandas之iloc
import pandas as pd
import numpy as np
t4=pd.DataFrame(np.arange(12).reshape(3,4),index=list("abc"),columns=list("WXYZ"))
print("全部信息:\n",t4)
print("当前行：\n",t4.iloc[1,:])
print("当前列：\n",t4.iloc[:,1])
print("当前任意列：\n",t4.iloc[:,[1,2]])
print("当前任意行：\n",t4.iloc[[1,2],:])
print("某行某列：\n",t4.iloc[2,1])
print("多行多列（不连续）：\n",t4.iloc[[1,2],[1,2]])
print("某行之后的多行(不包含)，某列之后的多列（不包含）：\n",t4.iloc[:1,2:]) #第1行之前，第2列之后
print("行后列前：\n",t4.iloc[1:,:2]) #第1行之后，第2列之前（不包含第2列）（前不包，后包）
print("行前列后：\n",t4.iloc[:2,1:]) #第2行之前，第1列之后（不包含第2行）
t3.iloc[:2,1:]=30 #赋值操作
print("赋值：\n",t3.iloc[:2,1:])
# print("",t3.iloc[[2,1]])
#pandas之布尔索引
import pandas as pd
import numpy as np
df=pd.read_csv("./dog.csv") # &表示且，|表示或
print(df[(80<df["Count_AnimalName"])&(df["Count_AnimalName"]<1000)])
#panda之字符串操作
import pandas as pd
import numpy as np
pd=pd.read_csv("./dog.csv")
get=pd.loc[11,["Row_Labels"]]#获取第11行,键值为"Row_Labels"的信息
print(get.str.split("/").tolist())
print(pd)# 输出文件内所有信息
- jieba库
- turtle库
- matplotlib导入字体
from matplotlib import font_manager
myfont=font_manager.FontProperties(fname="字体路径") #导入字体
>#应用字体举例
plt.title("字符"，fontproperties=myfont)
plt.xticks(, ,fontproperties=myfont)
plt.ylabel(,fontproperties=myfont)
plt.legend(prop=myfont,loc="upper left")
- 常规数学计算函数
- 内置函数
-
abs(x) 返回绝对值
-
max(x1,x2,...) 最大值，参数可为序列
-
min(x1,x2,...) 最小值
-
pow(x,y) x的y次方
-
round(x,[,n]) 四舍五入，n表示可以取到小数点后的位数
- math模块
- e 数学常量e
- pi 派
- sin(x),cos(x),tan(x) x的弧度
- degrees(x) 弧度转角度
- redians(x) 角度转弧度
- exp(x) e的x次方
- sqrt(x) 开平方
- fabs(x) 绝对值
- fmod 取模，取余
- fsum( seq) 序列求和
- ceil(x) 向上取整
- floor(x) 向下取整
- log(x,base) 以base为底，x的对数
- log2(x) 以2为底，x的对数
- log10(x) 以10为底，x的对数
- random模块
- random( ) [0,1)之间的一个随机数
- randint(start,end) [start,end]上的一个整数，包含max,可通过乘除得到浮点数
- uniform(start,end) [start,end]范围内的一个实数
- randrange(start, end,step) 在指定范围内随机返回一个数
- choice(seq) 从序列中随机返回一个数
- shuffle(seq) 将序列随机排序（打乱）
- seed(x) 设置种子，默认当前时间
- 进制转换
- 十转二
print(bin(2))
0b10
-十转八
print(oct(2))
0o2
- 十转十六
print(hex(2))
0x2
b:二进制 d:十进制 o:八进制 x:十六进制
- 知识点
- 线性结构与非线性结构：
- 线性结构是一个有序数据的集合,常见的线性结构有：线性表，栈，队列，双队列，数组，串，向量。
- 非线性，数学用语，其逻辑特征是一个结点元素有多个直接前驱和直接后继，常见的非线性结构有：二维数组，多维数组，广义表，二叉树
- 储存结构
- 二叉链表是二叉树的储存结构
- 循环列表是线性表的链式储存结构
- 栈和队列
-
出栈规则：“先进后出”或“后进先出”
-
出队规则：“先进先出”或“后进后出”
- 循环队列求元素个数
存储空间Q(0:59),初始状态为空 ，front=25,rear=24
rear-front>0? rear-front:rear-front+m
- 单元测试
主要针对模块的5个特征进行：
- 模块接口测试
- 局部数据结构测试
- 重要的执行路径检查
- 检查模块的错误处理能力
- 影响以上各点及其他相关点的边界条件测试
- 数据流图（DFD）
- 数据流图是系统逻辑模型的图形表示，从数据传递和加工角度，来刻画数据流从输入到输出的移动变化过程，它直接支持系统的功能建模
- 软件工程三要素
- 方法
- 工具
- 过程
- 软件开发不同阶段的工具
- 需求分析阶段DFD图
- 类的成员定义
- _s_ 保护成员
- __s__系统特殊成员
- __s_ 私有成员（以两个下划线或多个开始，一个或多个结束）
- 语言类型
- 分为静态和动态，静态采用编译方式执行，脚本采用解释方式执行
- C语言为编译，python为解释
- 编译是将源代码转换成目标代码的过程，解释是将源代码逐条转换成目标代码并运行目标代码的过程
- Web开发的库
Django库，Pyramid库，Flask库
- 树
- 树总的节点数=所有节点度之和+1
- 叶子节点数
- 结构化程序设计原则
自顶向下，逐步求精，模块化，限制使用goto语句
- 面向对象方法特点
- 可继承，可封装，多态性
- 白盒与黑盒测试
白盒测试主要有：逻辑覆盖，基本路径测试（动态测试）
黑盒测试主要有：等价类划分，边界值分析，错误推测，因果图
- 关系数据库
键：在关系（二维表）中凡是能唯一标识元组的属性或属性集合
- 编码转换
chr(x) 和 ord(x) 函数用于在单子符和Unicode编码之间转换
- 数据分析
包含的库：numpy,matplotlib,pandas,scipy
- 网络爬虫
包含的库：scrapy
- 游戏开发
包含的库：pygame
- 最坏情况下比较次数（排序）
-
冒泡排序，快速排序，简单插入排序，简单选择排序最坏情况下比较次数为n(n-1)/2
-
堆排序：nlog以2为底n的对数
-
希尔排序：n的r次方（1<r<2）
案例：
#案例：验证码
import random
s="QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm0123456789"
code=""
for i in range(4):
ran=random.randint(1,len(s)-1)
code+=s[ran]
print(code)
浙公网安备 33010602011771号