[Python知识库]python模块（学习笔记）

sys模块

定义

sys模块主要负责与Python解释器进行交互,该模块提供了一系列用于控制Python运行环境的函数和变量，用来获取操作系统和编译器的一些配置、环境设置以及操作。

常用方法

import sys

#使用help(sys)查看sys里面有哪些方法
help(sys)

#利用以上的不直观，我们可以dir
print(dir(sys))

代码

此代码在vscode里面写好在cmd窗口去运行
python 文件名字 参数
D:\axc\Python\PythonTemp>python count.py 12 3 4 5

sys.argv

import sys
print(sys.argv)#['d:/pythonfile/testCode.py']

exit(n)

退出 Python 程序，exit(0) 表示正常退出

for i  in range(10):
    if i==5:
        exit(0)
    print(i)
'''
0
1
2
3
4
'''

sys.version

获取 Python 解释程器的版本信息

import sys
print(sys.version) 
#3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)]

sys.maxsize

最大的 Int 值，在 64 位操作系统上是 263-1

print(sys.maxsize)  #9223372036854775807      

sys.path

返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值

print(sys.path)

import sys
print('Path 包括：', len(sys.path), '个部分构成')
sys.path.insert(0,"simple") #在路径首位置添加
print(sys.path)

a = sys.builtin_module_names
print(a) #所有内建模块的名字

sys.modules

以字典的形式返回所有当前 Python 环境中已经导入的模块

sys.modules.keys()

返回所有已将导入模块的key

import sys
print(sys.modules)
print("------------------------------------------------")
print(sys.modules.keys())

sys.getrefcount(object)

返回对象的引用数量

import sys
a = [1, 2, 3]
b = a
print(sys.getrefcount(a))    # 3
#注意，这个列表被a、b以及getrefcount()三个地方调用，因此输出结果为3。

练习

"""
 定义一个函数，属于一个名字，查看是否是内建模块
"""
import sys
def func(hh):
    if hh in sys.builtin_module_names:
      #查找内建模块是否存在
        print("是内建")
    else:
        print("不是内建")
func("path")

os模块

定义

os模块与操作系统交互，提供了访问操作系统底层的接口

常用方法

代码

os.getcwd()

获取当前目录

import os
print(os.getcwd())
#D:\axc\Python\PythonTemp

os.chdir

切换进入到哪个目录下

print(os.chdir(r"C:\"))

os.getcwd()

获取当前工作目录，即当前python脚本工作的目录路径

print(os.getcwd())

os.rename(old,new)

将old文件重命名为new

os.rename('本文件.py','test.py')

os.remove

删除文件

os.remove('test.py')

os.mkdi()

创建单级空文件夹，目录

os.mkdir('dis')

os.rmdir()

删除单级空目录

os.rmdir('dis')

os.makedirs

创建多层递归目录

os.makedirs('dis\\b')

os.removedirs

只能删除空的文件夹

os.removedirs('dis\\b')

os.listdir

列出指定目录下的所有文件及文件夹，包括隐藏文件，并返回一个list

print(os.listdir('指定目录'))

os.system(command)

#可以直接操作系统命令

os.system('ipconfig')

res=os.popen('ipconfig').read()
#执行操作系统命令print(res)

os.path.dirname

#返回path的目录,取父目录

import os
print(os.path.dirname('D:\\axc\\Python\\PythonTemp\\count.py'))
#D:\axc\Python\PythonTemp

os.path.split

将path分割成目录和文件名，并返回一个元组

print(os.path.split('D:\\axc\\Python\\PythonTemp\\count.py'))
#('D:\\axc\\Python\\PythonTemp', 'count.py')

os.path.join

将多个路径拼起来

print(os.path.join('program','python','code','student.py'))
#program\python\code\student.py

os.path.exists

判断path(文件或文件夹)是否存在

print(os.path.exists('D:\\axc\\Python\\PythonTemp\\count.py'))
#False

os.path.isfile

判断path是否是文件

print(os.path.isfile('文件路径'))

os.path.isdir

#判断path是否是目录，False

print(os.path.isdir('D:\\axc\\Python\\PythonTemp\\count.py'))

文件模式匹配：glob模块

import globimport os
#文件下面所有py为后缀的文件
for file in glob.glob("D:\\axc\\Python\\PythonTemp\\*.py"):
    print(file)print("-------------------------")
    print(os.listdir('D:\\axc\\Python\\PythonTemp'))
"""注意这里的glob返回指定的文件完整路径名，这点和os.listdir函数不同，os.listdir只是返回文件名。"""

正则表达式

定义

普通字符和元字符构成的字符串，描述一类字符串规则

元字符

有特殊含义的字符

import rea = re.findall("a.c","abcdefg")print(a) #['abc']#匹配a或者ca = re.findall("a|c","abdefgc")print(a) #['a', 'c']#匹配列表中的任意任意一个字符a = re.findall("[acbe]","abdefgc")print(a) #['a', 'b', 'e', 'c']#除了a和c其余都要a = re.findall("[^ac]","adfgcvs")print(a) #['d', 'f', 'g', 'v', 's']#a-c 意思是匹配abc三个字符a = re.findall("[a-c]","adfgcvs")print(a) #['a', 'c']#意思是把adf作为一个整体进行输出a = re.findall("(adf)","adfgcvs")print(a) #['adf']#去掉小数点的特殊含义，他就是一个小数点a = re.findall("\.","adf.gcvs")print(a) #['.']

转义字符

预定义匹配字符集

代码

#匹配出0-9的数字
a = re.findall("\d","abc1e34r")
print(a) 
#['1', '3', '4']
# `\d`的反集，也就是非数字的任意一个字符，等同于`[^\d]，除数字以外的
a = re.findall("\D","abc 123")print(a) 
#['a', 'b', 'c', ' ']
# 任意一个字母或数字或下划线，也就是A~Z,a~z,0~9,_ 中的任意一个  
a = re.findall("\w","abwc1e34r_")
print(a) 
#['a', 'b', 'w', 'c', '1', 'e', '3', '4', 'r', '_']
#`\w`的反集，也就是`[^\w]`  ，除字母以外的
a = re.findall("\W","abwc1 e34r_")
print(a)  
#[' ']
#都可以匹配下划线了，那空格怎么匹配
a = re.findall("\s","abc 123")print(a)  
#[' ']
#  `\s`的反集，也就是`[^\s]`,除空格以外  
a = re.findall("\S","abc 123")print(a)  
#['a', 'b', 'c', '1', '2', '3']

重复匹配

代码

import re
#意思是ll要有两个
a = re.findall("l{2}","yesall")
print(a)
#意思是l要有2个到4个
a = re.findall("l{2,4}","alyesallnoalllowallll")
print(a)
#['ll', 'lll', 'llll']
#意思是l最少要有两个，上不封顶
a = re.findall("l{2,}","alyesallnoallll")
print(a) 
#['ll', 'llll']
#意思是l至少有一个
a = re.findall("l+","yellowlow")print(a) 
#['ll', 'l']
#意思是l至少有0个
a = re.findall("l*","yellowlow")
print(a) 
#['', '', 'll', '', '', 'l', '', '', '']

位置匹配

#1是否在开头
a = re.findall("^1","1364156")
print(a) 
#['1']
#6是否在末尾
a = re.findall("6$","1364156")
print(a) 
#['6']

贪婪模式与非贪婪模式

“贪婪模式”总是尝试匹配尽可能多的字符；“非贪婪模式”则相反，总是匹配尽可能少的字符

练习

1.长度为8-10的用户密码（以字母开头、数字、下划线）

import re
#输入一个密码，验证长度为8-10的用户密码（以字母开头、数字、下划线）
s = input("请输入一个密码：")
a= re.findall("^[a-zA-Z]\w{7,9}",s) 
print(a)

2.电子邮箱验证

#电子邮箱验证
s = input("请输入一个电子邮箱：")
a= re.findall("^\w+@\w+[\.]\w+$",s) 
print(a) 
#newglf@163.com

3.电话号码的验证

num = input("请输入电话号码")
n  = re.findall("^1\[3-9]\d{9}",num) #电话号码11位
print(n) 

re模块

定义

re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的

常用方法

代码

查询模块

compile(pattern)

根据包含正则表达式的字符串创建模式对象

r = re.compile("[0-9]")
print(r) #返回一个编译正则的re对象
"""
re.IGNORECASE：忽略大小写，同 re.I。
re.MULTILINE：多行模式，改变^和$的行为，同 re.M。
re.DOTALL：点任意匹配模式，让'.'可以匹配包括'\n'在内的任意字符，同 re.S。
re.LOCALE：使预定字符类\w \W \b \B \s \S 取决于当前区域设定，同 re.L。
re.ASCII：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是Unicode 字符，同 re.A。
re.VERBOSE：详细模式。
"""
import re 
b = re.compile(r"[a-w]",re.I)
a = b.findall("ADbcG")
print(a) #['A', 'D', 'b', 'c', 'G']

search(pattern, string)

在字符串中查找 第一个匹配到的对象或者None

#扫描整个字符串，并返回它找到的第一个匹配（Match object）
r = re.compile("[0-9]")
a = r.search("123abc456")
print(a) #<re.Match object; span=(0, 1), match='1'>

match(pattern, string)

在字符串开头匹配到的对象或者None 返回一个match对象

r = re.compile("[0-9]")
a = r.match("123abc456") 
#a = r.match("123abc456")  #开头不是数字，所以输出None
print(a) #<re.Match object; span=(0, 1), match='1'>

findall(pattern, string,flags)

列出字符串中模式的所有匹配项 所有匹配到的字符串列表

r = re.compile("[0-9]")
a = r.findall("123abc4567")
print(a) #['1', '2', '3', '4', '5', '6', '7']

finditer(pattern, string,flags)

将所有匹配到的项生成一个迭代器 返回一个迭代器

r = re.compile("[0-9]")
a = r.finditer("123abc456")
print(a) #<callable_iterator object at 0x0000020C599BFA88>
print(list(a))
"""
[<re.Match object; span=(0, 1), match='1'>, 
<re.Match object; span=(1, 2), match='2'>, 
<re.Match object; span=(2, 3), match='3'>, 
<re.Match object; span=(6, 7), match='4'>, 
<re.Match object; span=(7, 8), match='5'>, 
<re.Match object; span=(8, 9), match='6'>]
"""

match相关方法

#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串  
"""
分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。
组0总是存在的，它就是整个表达式。
没有参数时，group1默认为0，这时返回整个匹配到的字符串。
"""
#空格不要忘了
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a)  #<re.Match object; span=(0, 6), match='I LOvE'>
print(a.group()) #I LOvE   默认是0
print(a.group(1)) #I
print(a.group(2)) #LOvE
print(a.group(3)) #报错

"""
 指定多个参数的时候，就返回一个元组
"""
print(a.group(1,2)) #('I', 'LOvE')

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.groups()) #('I', 'LOvE')

#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you") 
print(a.start()) #0  
print(a.start(2)) #2  第二个单词的起始位置是2，下标从0开始
#match.end(index) 匹配空格
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you") 
print(a.end()) #6
print(a.end(2)) #6
print(a.end(1))  #1

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.span()) #(0, 6)
print(a.span(1)) #(0, 1)
print(a.span(2)) #(2, 6)

拆分

#split(pattern, string)    根据模式的匹配项来分割字符串    分割后的字符串列表  
#意思是匹配到大写的字母就拆分
pattern = re.compile(r"[A-Z]+")
m = pattern.split("abcDefgHijkLmnoPqrs")
print(m) 
#['abc', 'efg', 'ijk', 'mno', 'qrs']

替换

"""       sub(repl, string,count=0)   将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串           |repl可以是一个字符串，也可以是一个函数。count用于指定最多替换次数，不指定时全部替换。"""   
r = re.compile(r"like", re.I)
#s1 = r.sub(r"love", "I like you, do you like me?")  #I love you, do you love me?
#最多替换1次，所以把一个like替换了
s1 = r.sub(r"love", "I like you, do you like me?",count=1)
print(s1) 
#I love you, do you like me?
#subn(repl, string) | 在替换字符串后，同时报告替换的次数    | 完成替换后的新字符串及替换次数 |
#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。
r = re.compile(r"like", re.I)
"""s1 = r.subn(r"love", "I like you, do you like me?")print(s1) #('I love you, do you love me?', 2)"""
s1 = r.subn(r"love", "I like you, do you like me?",count=1)
print(s1) #('I love you, do you like me?', 1)

补充 r

Python中字符串前面加上 r 表示原生字符串

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

日期时间相关：datetime模块

定义

python中的datetime模块提供了操作日期和时间功能, 该模块提供了一下类对象

两个属性

import datetimeprint(datetime.MINYEAR) #1print(datetime.MAXYEAR) #9999

datetime.date类

定义：

class datetime.date(year, month, day)

datetime模块下的日期类(date)，只能处理年月日这种日期时间，不能处理时分秒。

from datetime import date

#创建一个日期对象
date01 = date(year=2021, month=12, day=22)
print(date01.year) #2021
print(date01.month) #12
print(date01.day) #22

常用的方法和属性

代码

import timefrom datetime 
import dateprint(date.max)#最大  
# 9999-12-31
print(date.min)  
# 0001-01-01 
print(date.resolution)  
# 1 day, 0:00:00
print(date.today())  
# 2020-03-17  
print(date.fromtimestamp(time.time()))  
# 2020-03-17
d = date.today()  
print(d.year)  
# 2020
print(d.month)  
# 3
print(d.day)  
# 17
print(d.replace(2019))  
# 2019-03-17
print(d.replace(2019, 5))  
# 2019-05-17
print(d.replace(2019, 5, 21))  
# 2019-05-21
print(d.timetuple())  
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=77, tm_isdst=-1)
print(d.toordinal())  
# 737501
print(d.weekday())  
# 1
print(d.isoweekday())  
# 2
print(d.isocalendar())  
# (2020, 12, 2)
print(d.isoformat())  
# 2020-03-17
print(d.ctime())  
# Tue Mar 17 00:00:00 2020
print(d.strftime('%Y/%m/%d')) 
# 2020/03/17

datetime.time类

定义：

class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])

datetime模块下的时间类，只能处理时分秒。

from datetime import 
timea = time(11,59,59)
print(a) #11:59:59

常用方法

代码

from datetime import time

print(time.max)  # 23:59:59.999999
print(time.min)  # 00:00:00
print(time.resolution)  # 0:00:00.000001
t = time(12, 15, 40, 6666)
print(t.hour)   # 12
print(t.minute)  # 15
print(t.second)  # 40
print(t.microsecond)  # 6666
print(t.replace(21))  # 21:15:40.006666
print(t.isoformat())  # 12:15:40.006666
print(t.strftime('%H%M%S'))  # 121540
print(t.strftime('%H%M%S.%f'))  # 121540.006666

datetime.datetime类

定义：

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

一定要注意这是datetime模块下的datetime类，千万不要搞混了！datetime模块下的日期时间类，你可以理解为datetime.time和datetime.date的组合类

from datetime import datetimea = datetime(year=2021, month=12, day=3, hour=10, minute=59, second=59)print(a) #2021-12-03 10:59:59

常用方法

datetime.timedelta类

定义：

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0)

timedelta对象表示两个不同时间之间的差值。可以对datetime.date, datetime.time和datetime.datetime对象做算术运算

常用方法

import datetime
#一年有多少秒
print(datetime.timedelta(365).total_seconds())   #31536000.0
#获取现在时间
dt = datetime.datetime.now()

"""
print(dt) #2021-10-04 17:22:31.928545
print(dt + datetime.timedelta(3))    # 3天后 2021-10-07 17:23:33.130410
print(dt + datetime.timedelta(-3))   # 3天前 2021-10-01 17:23:33.130410
print(dt + datetime.timedelta(hours=3))  # 3小时后 2021-10-04 20:24:30.536769
print(dt + datetime.timedelta(hours=-3))  # 3小时前 2021-10-04 14:24:30.536769
print(dt + datetime.timedelta(hours=3, seconds=30))  # 3小时30秒后 2021-10-04 20:25:55.309684

"""

dt2 = dt + datetime.timedelta(hours=10)
print(dt2 - dt)  # 10:00:00
td = dt2 - dt
print(td.seconds)  # 36000

pprint模块

定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

Printing

使用 pprint 模块的最简单方法是调用 pprint() 方法：

定义

pprint模块包含一个“美观打印器(PrettyPrinter)”，用于产生美观的数据结构视图。格式化程序生成可以由解释器正确解析的数据结构，并且容易使人阅读

"""
pprint.pprint`(*object*,*stream=None*,*indent=1*, *width=80*, *depth=None*)

indent --- 缩进，width --- 一行最大宽度，
depth --- 打印的深度，这个主要是针对一些可递归的对象，如果超出指定depth，其余的用"..."代替。

             eg: a=[1,2,[3,4,],5]  a的深度就是2; b=[1,2,[3,4,[5,6]],7,8] b的深度就是3

stream ---指输出流对象，如果stream=None，那么输出流对象默认是sys.stdout
"""

代码

from pprint import pprint
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]

#这种是打印一行
print(data)
pprint(data)
"""
[('大数据一班', {'张三': 18, '李四': 20}),
 ('大数据二班', {'张三': 18, '李四': 20}),
 ('大数据三班', {'张三': 18, '李四': 20}),
 ('大数据四班', {'张三': 18, '李四': 20})]
"""

Formatting

定义

格式化数据结构

补充:日志的讲解

https://blog.csdn.net/colinlee19860724/article/details/90965100

import logging
from pprint import pformat
data = [("大数据一班",{"张三":18,"李四":20}),
("大数据二班",{"张三":18,"李四":20}),
("大数据三班",{"张三":18,"李四":20}),
("大数据四班",{"张三":18,"李四":20})]

#.basicConfig() 使用默认格式化程序创建 StreamHandler 并将其添加到根日志记录器中，从而完成日志系统的基本配置。如果没有为根日志程序定义处理程序，debug()、info()、warning()、error()和 critical() 函数将自动调用 basicConfig()。
logging.basicConfig(
    #级别排序：CRITICAL > ERROR > WARNING > INFO > DEBUG。
    level=logging.DEBUG,
    #为处理程序使用指定的格式字符串。
    #%(levelname) 日志级别  %(message)s已经记录的消息
    format='%(levelname)s %(message)s',
)
#打印
logging.debug('Logging pformatted data')
#对data进行格式化
formatted = pformat(data)
#Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
for line in formatted.splitlines():
    #Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）
    #可写可不写
    logging.debug(line.rstrip())

"""
DEBUG Logging pformatted data
DEBUG [('大数据一班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据二班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据三班', {'张三': 18, '李四': 20}),
DEBUG  ('大数据四班', {'张三': 18, '李四': 20})
"""

练习

import logging
from pprint import pformat
"""
 把下面的报错加上error
"""
data = ["FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:org.apache.hadoop.hbase.client.RetriesExhaustedException: Can't get the locations",
	"at org.apache.hadoop.hbase.client.RpcRetryingCallerWithReadReplicas.getRegionLocations(RpcRetryingCallerWithReadReplicas.java:312)",
	"at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:153)",
	"at org.apache.hadoop.hbase.client.ScannerCallableWithReplicas.call(ScannerCallableWithReplicas.java:61)",
	"at org.apache.hadoop.hbase.client.RpcRetryingCaller.callWithoutRetries(RpcRetryingCaller.java:200)",
	"at org.apache.hadoop.hbase.client.ClientScanner.call(ClientScanner.java:320)",
	"at org.apache.hadoop.hbase.client.ClientScanner.nextScanner(ClientScanner.java:295)",
	"at org.apache.hadoop.hbase.client.ClientScanner.initializeScannerInConstruction(ClientScanner.java:160)",
	"at org.apache.hadoop.hbase.client.ClientScanner.<init>(ClientScanner.java:155)",
	"at org.apache.hadoop.hbase.client.HTable.getScanner(HTable.java:811)",
	"at org.apache.hadoop.hbase.MetaTableAccessor.fullScan(MetaTableAccessor.java:602)",
	"at org.apache.hadoop.hbase.MetaTableAccessor.tableExists(MetaTableAccessor.java:366)",
	"at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:303)",
	"at org.apache.hadoop.hbase.client.HBaseAdmin.tableExists(HBaseAdmin.java:313)"]

#.basicConfig()
logging.basicConfig(
    #级别排序：CRITICAL > ERROR > WARNING > INFO > DEBUG。
    level=logging.ERROR,
    #为处理程序使用指定的格式字符串。
    #%(levelname) 日志级别  %(message)s已经记录的消息
    format='%(levelname)s %(message)s',
)
#打印
logging.error('Logging pformatted data')
#对data进行格式化
formatted = pformat(data)
#Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
for line in formatted.splitlines():
    #Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）
    #可写可不写
    logging.error(line.rstrip())

pickle模块

定义

pickle模块只能在python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化。

序列化方法

dumps()与loads()

"""
dumps(数据类型) 将python转换成二进制
loads(二进制) 将二进制转换成python
"""
import pickle as p 

String01 = "I love you"
a = p.dumps(String01)
print(a) #b'\x80\x03X\n\x00\x00\x00I love youq\x00.'

b = p.loads(a)
print(b) #I love you

dump()与load()

"""
dump(数据类型,文件对象) 把python转成二进制写入文件
load(文件对象) 把文件中的数据读取成二进制转成python
"""
import pickle as p

list01 = ["小明","翠花","王五","张三"]
#因为只能是二进制的，所以文件要声明成b。要写进去所以是w
#open("f.txt","x") 
#创建一个文件
f1 = open("f.txt","wb")
p.dump(list01,f1) #文件是个二进制文件，打不开

f1 = open("f.txt","rb")#r代表的是读
a = p.load(f1)
print(a) #['小明', '翠花', '王五', '张三']

文件的操作

创建/打开文件

语法

"""
 变量名 = open(文件名，打开模式)
"""

打开模式

代码

#在路径下面创建text.py文件
#f =  open("text.txt","x")
#在桌面上创建test。windows下面\有转义的意思
#f =  open("C:\\Users\\wangyujun\\Desktop\\text.txt","x")
#想要打开的文件进行什么操作，就使用是什么模式
f =  open("text.txt","r")

关闭文件

f.close()#必须关闭文件，因为每次操作都是保存在内存中，并没有真正保存到文件中

读文件

常用方法

代码

注意：如果文件是中文，打开之后报错。就按照一下步骤修改

文件—>首选项—>设置—>搜索encoding---->simplified chiese (GBK)

#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","r")
# <f>.read()      | 读入全部内容
#r1=f.read()
#print(r1)
# <f>.readline(size)  | 读入一行内容，如果给出参数，读入该行前size长度  
r2 = f.readline()   
print(r2)  
#伟大的中国
r3 = f.readline(2)   
print(r3)  
#伟大   
# <f>.readlines(hint=-1) | 读入文件所有行，以每行为元素形成列表 如果给出参数，读入前hint行
r4 = f.readlines()
print(r4) 
#['伟大的中国\n', '伟大的人民\n']
#第四种
for i in f.readlines():    
print(i)

写文件

常用方法

代码

#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","w")
#  <f>.write(s)     
#向文件写入一个字符串或字节流    
s = "少年强则国强"
f.write(s)
# <f>.writelines(lines)   
# 将一个元素全为字符串的列表写入文件  
l = ["馒头","大米","红烧肉"]
f.writelines(l)
#  <f>.seek(offset)   
# 改变当前文件操作指针的位置，offset含义如下：  0  – 文件开头；  1  – 当前位置；  2  – 文件结尾   
f.seek(2)
f.write("zuguo")

#读文件也可以这样操作，但是这里的文本必须是英文，编码格式必须是UTF-8
#首先我们要打开一个文件，需要有一个文件的对象
f = open("test.txt","r+")
#这里的指针是指第一行的从几到几
#下标是从0开始的
f.seek(4)
r1 = f.readline()
print(r1)

删除文件

import osos.remove("test.txt")

with语句

语法

"""with open(文件名) as 别名"""

代码

"""
f =  open("f.txt","rb")
a = f.readline()
print(a)
#打开一个文件，每一次都需要关闭文件f.close()
"""
#和上面是一样的，只是不需要去关闭流
with open("f.txt","rb") as f:    
a = f.readline()    
print(a)

json模块

定义

Json是一种轻量级的数据交换格式。Json源自JavaScript语言，易于人类的阅读和编写，同时也易于机器解析和生成，是目前应用最广泛的数据交换格式。

#{}是一个对象  []数组
{    "大数据1班":[{"张三":15,"李四":18,"赵六":20}],    "大数据2班":[{"张三":15,"李四":18,"赵六":20}],    "大数据3班":[{"张三":15,"李四":18,"赵六":20}],    "大数据4班":[{"张三":15,"李四":18,"赵六":20}],    "大数据5班":[{"张三":15,"李四":18,"赵六":20}],    "大数据6班":[{"张三":15,"李四":18,"赵六":20}],    "大数据7班":[{"张三":15,"李四":18,"赵六":20}],    "大数据8班":[{"张三":15,"李四":18,"赵六":20}],    "大数据9班":[{"张三":15,"李四":18,"赵六":20}],    "大数据10班":[{"张三":15,"李四":18,"赵六":20}],
}

Python内置类型转换JSON类型对照表

JSON类型转换Python类型对照表

常用方法

dumps()与loads()

json.dumps

参数
“”"

json.dumps(obj, skipkeys=False, ensure_ascii=True,check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding=“utf-8”, default=None, sort_keys=False, **kw)
sort_keys =True:是告诉编码器按照字典排序(a到z)输出。如果是字典类型的python对象，就把关键字按照字典排序。
indent:参数根据数据格式缩进显示，读起来更加清晰。一般写2和4
separators:是分隔符的意思，参数意思分别为不同dict项之间的分隔符和dict项内key和value之间的分隔符，
skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key
ensure_ascii=True：默认输出ASCLL码，如果把这个该成False,就可以输出中文。

check_circular：如果check_circular为false，则跳过对容器类型的循环引用检查，循环引用将导致溢出错误(或更糟的情况)。
allow_nan：如果allow_nan为假，则ValueError将序列化超出范围的浮点值(nan、inf、-inf)，严格遵守JSON规范，而不是使用JavaScript等价值(nan、Infinity、-Infinity)。
default：default(obj)是一个函数，它应该返回一个可序列化的obj版本或引发类型错误。默认值只会引发类型错误。

"""
dumps(python数据) 把python数据转换成json数据
loads(json) 把json数据转换成python数据
"""
import json

print(json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])) # 输出结果：["foo", {"bar": ["baz", null, 1.0, 2]}]
print(json.dumps("\"foo\bar")) # 输出结果："\"foo\bar" 里面相当于是一个整体
print(json.dumps('\u1234')) # 输出结果："\u1234"
print(json.dumps('\\'))  # 输出结果："\\"

#如果sort_keys是False，则随机打印结果，如果sortkeys为true，则按顺序打印
print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)) # 输出结果：{"a": 0, "b": 0, "c": 0}

"""
这里indent是缩进的意思一般写为4 或者2
separators 是（ ‘元素之间用逗号隔开’ ， ‘key和内容之间’ 用冒号隔开）
这里是 ‘逗号’ ， ‘冒号’ 中间的逗号不带引号
"""
print(json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':')))
# 输出结果：[1,2,3,{"4":5,"6":7}]
print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))

"""
这里indent是缩进的意思一般写为4 或者2separators 是（ ‘元素之间用逗号隔开’ ， ‘key和内容之间’ 用冒号隔开）这里是 ‘逗号’ ， ‘冒号’ 中间的逗号不带引号"""
a = json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':')) # 输出结果：[1,2,3,{"4":5,"6":7}]
print (json.loads(a))

#\b就有特殊的意义，单词边界，本身没有什么意思
b = json.dumps("\"foo\bar")
print (json.loads(b)) #"foar  

dump()与load()

"""
dump(python,文件对象) 把python转换成json格式并保存到文件中load(文件对象) 
把json格式的文件读取转换成python
"""
import jsondata = {    "大数据1班":[{"张三":15,"李四":18,"赵六":20}],    "大数据2班":[{"张三":15,"李四":18,"赵六":20}],    "大数据3班":[{"张三":15,"李四":18,"赵六":20}],    "大数据4班":[{"张三":15,"李四":18,"赵六":20}],    "大数据5班":[{"张三":15,"李四":18,"赵六":20}],    "大数据6班":[{"张三":15,"李四":18,"赵六":20}],    "大数据7班":[{"张三":15,"李四":18,"赵六":20}],    "大数据8班":[{"张三":15,"李四":18,"赵六":20}],    "大数据9班":[{"张三":15,"李四":18,"赵六":20}],    "大数据10班":[{"张三":15,"李四":18,"赵六":20}],}with open("f.txt","w") as f:    a = json.dump(data,f)    
#print(a) 
#没有返回值，但是数据已经写进去了
rwith open("f.txt","r") as f:    
a = json.load(f)    
print(a)

Python与数据库

数据库

windows安装数据库

https://blog.csdn.net/weixin_45955039/article/details/120687285?spm=1001.2014.3001.5501

创建

updata------------>dml (数据操作语言)
insert------------>dml (数据操作语言)
delete------------>dml (数据操作语言)
select------------>dql (数据查询语言)

创建数据库

CREATE DATABASE 数据库名;

创建数据表

语法

CREATE TABLE IF NOT EXISTS table_name (column_name column_type);

数据类型

约束

主键自增（int）

primary key auto_increment

外键

CONSTRAINT <约束名>
FOREIGN KEY <外键名>(字段名1，字段名2...)
REFERENCES <主表名>(主键字段名)

唯一约束

<字段名> <数据类型> UNIQUE

非空约束

not null

默认约束

<字段名> <数据类型> DEFAULT <默认值>

切换数据库

使用/切换这个数据库：

use 数据库名字；

增(添加数据)

insert into 表名（列名1，列名2） values（值1，值2）

删

delete from 表名 where 表达式  #删除单个语句drop database 库名字； #输出数据库drop table 表名字;#输出数据表

改

语法

更新数据
关键字 update

update 表名 set 列名=值 [where 表达式]

修改数据
关键字 alter

alter table 旧表名 rename  to 新表名; #修改表名字
alter table 表名字 modify 列名 (新)数据类型; #修改数据类型 id char(10)---->id int
alter table 表名字 change 旧列名字 新列名字 新数据类型；#修改列名字  studentname-->name
alter table 表名 drop 列名;#删除某一列
alter table 表名 add 新列名 （新列名）数据类型;#添加一个列
alter table 表名 modify 列名1 数据类型 after 列名字2;#把列1插入到列2后面

查

语法

select 要查询的列名1，列名2 from 表名1,表2 
where 表达式1 and/not/or 表达式2
order by 列名字 desc/asc #order by 排序 desc降序 asc升序
limit 数字 #限制查询的条数 limit（2, 5）第2条数据到第5条数据

练习

创建学生信息表。字段有：学生id（主键自增），学生姓名，性别，生日，电话（不为空），身份证号（唯一）创建科目表：字段有：科目id（主键自增），科目名字成绩表：成绩id（主键自增，成绩，科目id（外键），学生id（外键））分别插入十条数据

#学生信息表
create TABLE studentInfo(
studentId int auto_increment primary key,
StudentName varchar(20),
#性别
Gender varchar(2),
Birthday date,
Age int(4),
BeginYear year,
Phone  varchar(11) not null,
idcard varchar(20) not null unique
);

#科目表
create TABLE subject(
subjectId int auto_increment primary key,
subjectname varchar(20)
);

#成绩表
create TABLE exam(
examId int auto_increment primary key,
exam float(4),
subjectid int,
constraint fk_subjectr_id foreign key(subjectid) references subject(subjectId),
studentid int,
constraint fk_student_id foreign key(studentid) references studentInfo(studentId)
);

python与数据库

1.安装pymsql

pip install pymysql列出软件包清单
pip list查看软件包信息
pip show django

2.连接mysql

连接方法

'''
pymysql.connect(host,user, password,port,db,charset)
host：MySQL服务器所在的主机的ip；
user：用户名
password：密码
port：连接的MySQL主机的端口，默认是3306
db：连接的数据库名
charset：当读取数据出现中文会乱码的时候，需要我们设置一下编码；python3默认采用的utf8字符集
'''

首先打开服务----->启动mysql

代码

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')
#运行不报错就是可以了

3.cursor游标对象

定义

它负责执行我们熟悉的SQL语句

开启游标

# 开启mysql的游标功能，创建一个游标对象；
cur = db.cursor()

常用方法

区别是：批量添加的时候executemany比较快

# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from exam;" 
# 使用游标对象执行SQL语句；
cur.execute(sql)

cursor用来查询数据的方法

我们执行完sql语句怎么查询返回的受影响的函数呢，有以下及格方法

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')
#运行不报错就是可以了

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()

# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from exam;"  
# 使用游标对象执行SQL语句；
cursor.execute(sql)
# 使用fetchone()方法，获取返回的结果，但是需要用变量保存返回结果；
#data = cursor.fetchone() #(1, '张三', 60)  单条数据
#多条数据
#data = cursor.fetchall() #((1, '张三', 60), (2, '李四', 60), (3, '王五', 80))
#两条数据
data = cursor.fetchmany(2) #((1, '张三', 60), (2, '李四', 60))
print(data)
# 断开数据库的连接，释放资源；
db.close()

游标类型

# 开启mysql的游标功能，创建一个游标对象；             
 cursor = db.cursor(cursor=DictCursor)

4.操作数据库

创建表

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')
#运行不报错就是可以了

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()

#创建表，字段是id，姓名，年龄，性别
sql = """
CREATE TABLE ceshi(
    id int,
    name varchar(10),
    age int,
    sex char(10)
) 

"""  
# 使用游标对象执行SQL语句；
cursor.execute(sql)
# 断开数据库的连接，释放资源；
db.close()

插入数据

插入单调

 import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')
#运行不报错就是可以了

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()

#插入数据
sql = """
insert into ceshi(id, name, age, sex)
values(%s,%s,%s,%s)
"""  
try:
      # 使用游标对象执行SQL语句；
	cursor.execute(sql,(2,"翠花",19,"男"))
        db.commit()
except Exception as ex:
        print('插入语句错误' + str(ex))
        db.rollback()
finally:
        db.close()
                  

插入多条数据

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')
#运行不报错就是可以了

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()

#插入数据
sql = """
insert into ceshi(id, name, age, sex)
values(%s,%s,%s,%s)
"""  
data = [
    (3,"王五",19,"男"),
    (4,"李四",19,"男"),
    (5,"赵六",19,"男")
]

try:
      # 使用游标对象执行SQL语句；
		cursor.executemany(sql,data)
        db.commit()
except Exception as ex:
        print('插入语句错误' + str(ex))
        db.rollback()
finally:
        db.close()

查询数据

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据
sql = "select * from ceshi;"  
# 使用游标对象执行SQL语句；
cursor.execute(sql)
#多条数据
data = cursor.fetchall() 
print(data)
# 断开数据库的连接，释放资源；
db.close()

更新数据

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据
sql = "update ceshi set age=%s, sex=%s where id=%s;"  
try:
       # 使用游标对象执行SQL语句；
		cursor.execute(sql,(50,"女",3)) 
        db.commit()
except Exception as ex:
        print('插入语句错误' + str(ex))
        db.rollback()
finally:
        db.close()

删除数据

import pymysql

db=pymysql.connect(host='localhost',
                   user='root',
                   password='123456',
                   port=3306,
                   db='temp',
                   charset='utf8')

# 开启mysql的游标功能，创建一个游标对象；              
cursor = db.cursor()
# 要执行的SQL语句，确保数据表中有相应的数据 
sql = 'delete from ceshi where id=%s'
try:
        cursor.execute(sql, 3)  
        db.commit()
except Exception as ex:
        print('插入语句错误' + str(ex))
        db.rollback()
finally:
        db.close()

总结：执行事务（复习）

事务机制可以确保数据一致性。

事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

· 原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的各种操作要么都做，要么都不做。

· 一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

· 隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

· 持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

在pymysql模块是默认开启MySQL的事务功能的，MySQL不会自动提交所执行的相关SQL语句。因此，进行"增"、“删”、"改"的时候，一定要使用db.commit()提交事务，否则就看不见所插入的数据。

同时，进行"增"、“删”、"改"的时候，一定要使用try…except…语句，因为SQL语句一旦没有执行成功，我们可以使用db.rollback()回滚到操作之前的状态；当语句执行成功，我们就db.commit()提交事务。

练习

1.创建school数据库，使用数据库（直接使用mysql进行执行）

以下使用python连接mysql进行执行

2.创建学生表（学号主键，姓名，性别，班级，出生年月）

创建教师表（教师编号主键，姓名，性别，出生年月，职称）

创建课程表（课程编号主键，课程名称，教师编号外键）

创建成绩表（学号外键，课程编号外键，成绩）

3.以上四个表格插入数据

4.满足以下需求

4.1查询Student表中的所有记录的Sname、Ssex和Class列。

4.3以班级降序查询学生表的所有记录。

4.4查询Score表中成绩在60到80之间的所有记录

4.5查询每门课的平均成绩

4.6查询课程编号为1的,并且成绩高60 有同学的记录。

4.7查询"男"教师及其所上的课程。

#***************MySQL******************
import pymysql
db = pymysql.connect(
    host="localhost",
    user="root",
    password="wt222",
    port=3306,
    db="school",
    charset="utf8"
)
cur = db.cursor()
'''
sql = """
create table if not exists student(
    s_id int(20) primary key auto_increment,
    s_name varchar(4),
    s_sex varchar(2),
    s_class int,
    birthday datetime
);
"""
#执行sql语句
cur.execute(sql)
#提交数据
db.commit()
'''
'''
#创建游标对象---->负责执行sql语句
sql = """
insert into 
student(s_name,s_sex,s_class,birthday)
values(%s,%s,%s,%s);
"""
list01 = [
    ('赵磊','男','一班',19990224),
    ('钱红','女','二班',20010811),
    ('王强','男','二班',20000920),
    ('李慧','女','四班',20020309),
    ('陈翔','男','三班',19930425),
    ('周久','男','五班',19981102),
    ('张欣','女','九班',20050306)
]
cur.executemany(sql,list01)
db.commit()
'''
#================================================================

'''
sql = """
create table if not exists teacher(
    t_id int(20) primary key auto_increment,
    t_name varchar(4),
    t_sex varchar(2),
    birthday date,
    jobname varchar(10)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into teacher
(t_name,t_sex,birthday,jobname)
values(%s,%s,%s,%s);
"""
list02 = [
    ('李飞','男','1991-02-24','主任'),
('程伟丽','女','1977-08-11','秘书'),
('赵阳','男','1983-09-20','校长'),
('李慧珍','女','1995-03-09','处长'),
('陈浩','男','1993-04-25','老师'),
('周天宝','男','1999-11-02','组长'),
('张德明','男','2000-03-06','监察长')
]
cur.executemany(sql,list02)
db.commit()
'''
#===============================================
'''
sql = """
create table if not exists course(
    c_id int(20) primary key auto_increment,
    c_name varchar(20),
    t_id int(20),
foreign key(t_id) references teacher(t_id)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into course
(c_id,c_name,t_id)
values(%s,%s,%s);
"""
list03 = [
    ('01','大学物理','1'),
('02','高分子材料化学','2'),
('03','计算机科学与技术','3'),
('04','通信工程','4'),
('05','生物科学技术','5'),
('06','大数据技术','6')
]
cur.executemany(sql,list03)
db.commit()
'''
#==========================================
'''
sql = """
create table if not exists sourse(
    s_id int(20),
    c_id int(20),
    s_score int(3),
foreign key(s_id) references student(s_id),
foreign key(c_id) references course(c_id)
);
"""
cur.execute(sql)
db.commit()
'''
'''
sql = """
insert into sourse
(s_id,c_id,s_score)
values(%s,%s,%s);
"""
list04 = [
    ('1','01','88'),
('2','02','90'),
('3','03','55'),
('4','04','60'),
('5','05','79'),
('6','06','97')
]
cur.executemany(sql,list04)
db.commit()
'''
#==========================================
"""
sql = "select s_name,s_sex,s_class from student;"
a =cur.execute(sql)
a = cur.fetchall()
print(a)
'''
(('赵磊', '男', '一班'), 
('钱红', '女', '二班'),
 ('王强', '男', '二班'), 
 ('李慧', '女', '四班'), 
 ('陈翔', '男', '三班'), 
 ('周久', '男', '五班'),
  ('张欣', '女', '九班'))
'''
"""

"""
sql = "select * from student order by s_class desc;"
b =cur.execute(sql)
b = cur.fetchall()
print(b)
"""

sql = "select avg(s_score) from sourse;"
c =cur.execute(sql)
c = cur.fetchall()
print(c)

数学：math模块

定义

math模块是python中的数学函数模块，进行一些数学计算功能

基本函数

import math

a = math.ceil(3.2) #向上取整
a = math.floor(3.2) #向下取整
a = math.pow(3,2) #3的2次方
a = math.sqrt(4) #开平方
a = math.fabs(-1) #绝对值 
a = math.copysign(4, -2) #符号是符号，值是数值
a = math.factorial(4) #阶乘  4*3*2*1
a = math.fmod(4,2) #取余
a = math.fsum([2,3])   #迭代器的和
print(a)

定义常数

对数和三角函数

在数学里面，log用于表示一般的对数，可以用任意一个数作为底数。. 【举例，2的2次方等于4，那么，log2 (4)就等于2。. 】. 而lg在数学里面称为常用对数，常用对数就是以10为底数的对数。. 【举例，10的2次方等于100，那么lg (100)就等于2。. 】.

代码

import math

a = math.log(5)
a = math.log(2,5)
a = math.log2(5)
a = math.log10(2)
a = math.sin(5)
print(a)

random模块（随机数）

常用方法

针对浮点数

import random as ra
#random.random() 随机生成一个浮点数
print(ra.random()) #0.7025318415790162

针对整数

import random as ra
"""
random.randint(start,stop) 随机生成一个start,stop之间的整数 
随机产生start-stop之间的整数，包括start和stop。
"""
for i in range(10):
    a = ra.randint(0,10)
    print(a)
   
"""
random.randrange(start,stop,step)  随机生成一个start,stop之间的整数 
1.random.randrange(stop)  不写start，默认是0
2.左开右闭
3.step 步长,间隔
"""
#a = ra.randrange(10) #0-9之间的数据，不包含10
#a = ra.randrange(1,10) #1-10,不包含10
a = ra.randrange(1,10,2) #步长2，相当于奇数
print(a)

针对序列类型

import random as ra
"""
random.choice(sequence)  从一个序列中随机选择一个元素 
1.只能从字符串、元组、列表中随机获取
"""
# 
String01 = "I love you"
list01 = ["张三","李四","王五","赵六"] 
tuple01 = (1,2,3)  
# 报错 dict01 = {"张三":14,"王五":20,"李四":40}
# 报错 set01 = {1,2,3,4}
a = ra.choice(String01)
print(a)

import random as ra

#random.shuffle(sequence)  随机打乱列表的顺序,原列表发生变化 
#自能是列表类型
String01 = "I love you" #报错 字符串是字母有序的组合
list01 = ["张三","李四","王五","赵六"] 
tuple01 = (1,2,3)  #报错
dict01 = {"张三":14,"王五":20,"李四":40} #报错
set01 = {1,2,3,4} #报错
ra.shuffle(list01)
print(list01)

import random as ra
#random.sample(population,k) 从序列中随机抽取k个元素，返回一个新元素
#字典不可以
String01 = "I love you" 
list01 = ["张三","李四","王五","赵六"] 
tuple01 = (1,2,3)
dict01 = {"张三":14,"王五":20,"李四":40} #报错
set01 = {1,2,3,4} 
a= ra.sample(set01,3)
print(a)

练习

1.随机生成3个0-9之间的整数，若其中有两个值相等，则提示中奖，否则提示谢谢参与

#随机生成3个0-9之间的整数，若其中有两个值相等，则提示中奖，否则提示谢谢参与
import random
a1 = int(random.random()*10)
a2 = int(random.random()*10)
a3 = int(random.random()*10)
print(a1,a2,a3)
if a1==a2 or a2==a3 or a1==a3:
     print("中奖")
else:
     print("谢谢参与")

2.红包随机。

比如30元随机4个红包，

rom random import random


def hbsj(num,money):
    list01 = []
    num01 = num #num01 = 4
    for i in range(num):
        num01 -= 1 #3 2 1 0
        if num01 >0: #3 2 1
            m = random.randint(1,money)
        else:
            m = money #最总剩下的钱数都给最后一个人
        money -= m #m是领走的钱，我们的总钱数money要减去领走的钱m
        list01.append(m/100)

面向对象

类和对象是面向对象的两大核心

类

定义

类是对一群具有相同特征和行为的事物的统称，是抽象的

特征被称为属性，行为被称为方法

语法

类型要符合大驼峰命名
class 类名(object):
    def 方法名(self,参数)：
    	代码块
    def 方法名(self,参数)：
       代码块

对象

定义

对象是由类创建的具体存在，在程序中现有类才有对象

比如制作飞机，要先有图纸再有飞机这个实体

语法

创建对象的语法
对象名 = 类名()

代码

class animals:
    color = "yellow"
    def sellp(self):
        print("睡觉")
    def eat(self,food):
        print("吃"+food)


dog = animals()
print(dog.color)
dog.eat("骨头")  

补充

1.类需不需要参数，比如类名（object）

可以写也可以不写，python3.x中的所有类都继承了object，即使你不写也会默认继承object

2.方法为什么要用self

self是类的实例，并不是一个类

self和java中的this一样，你可以使用this，但是在python中约定俗成的就是self

class animals(object):
    color = "yellow"
    def duixiang(self):
        print(self)
    def sellp(self):
        print("睡觉")
    def eat(self,food):
        print("吃"+food)

class dog(animals):
    def duixiang(self):
        print(self)
"""
self是类的对象，是本类的对象，即使是继承关系，他也是子类的对象，并不是父类的对象
"""
d = dog()
d.duixiang()
an = animals()
an.duixiang()

自定义类

#pass是空语句，不做任何事情，只是为了保持结构的完整性
#初始化就相当于我们的构造函数，给参数一个默认值，或者是定义某些参数
class animals():
    def __init__(self,name,color="白色",age=5):
        self.name = name
        self.color = color
        self.age = age
    def eat(self,food):
        print("爱吃"+food)
    def jiao(self,jiaosheng):
        print(jiaosheng)
        print(self)
dog = animals("小白")
dog.eat("骨头")           

练习

class person():
    def __init__(self,name,sex="男",age=18):
        self.name = name
        self.sex = sex
        self.age = age
    def sleep(self):
        print("睡觉")
    def eat(self):
        print("一天三顿饭")
    def qita(self,zhiye):
        print(zhiye)
    #相当于我们tostring方法，把所有的信息展示出来
    def show(self):
        s = '姓名：%s,性别：%s,年龄：%d' %(self.name,self.sex,self.age)
        return s

student =person("小明")
print(student.show())
student.qita("学习")

继承

继承：继承就是子类继承父类的特征和行为，python支持多继承，多继承在以后不常用，最多会出现三个继承，因为他很复杂，我们拿单继承举例

语法

class 类1(object):
    pass
class 类2(object)：
    pass
class 类3(类1，类2)：
    pass

代码

"""定义一个人类学生类继承人类，同时定义一个花钱的方法"""class person():    def __init__(self,name,sex="男",age=18):        self.name = name        self.sex = sex        self.age = age    def sleep(self):        print("睡觉")    def eat(self):        print("一天三顿饭")    def qita(self):        print("不同的人有不同的任务")    def show(self):        s = '姓名：%s,性别：%s,年龄：%d'%(self.name,self.sex,self.age)        return sclass student(person):    def huaqian(self):        print("花钱神兽")#同样我们可以调用人类中的方法和属性#继承person类以后，初始化方法也继承过来了，所以一定不要忘了给参数s = student("小明")print(s.show())

class aminal():    def eat(self):        print("都需要吃饭")class person():    def gongzuo(self):        print("赚钱养女朋友")class teacher(aminal,person):    def hauqian(self):        print("花钱消费任性")t = teacher()t.eat()t.gongzuo()t.hauqian()

重点（一定要会）

1.继承完以后我们可以不可以重写方法

代码

#学生不应该是个对象，是个类的话更加好操作，那把学生定义成类，他要继承人类
class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
print(s.show())
#我们调用其他会发现，调用的是子类的其他，并不是父类的其他
"""
所以我们python也支持重写
1.不同的两个类    2.继承关系      3.方法名，参数相同
"""
s.qita()

2.能不能保留父类的一些方法里面的代码

代码

class student(person):
    def huaqian(self):
        print("花钱神兽")
    def qita(self):
        #调用父类的方法
        super().qita()
        print("学生的任务是：好好学习天天向上")

#继承person类以后，初始化方法也继承过来了
s = student("小明")
"""
可不可以保留这样的一句话，
不同的人有不同的任务，学生的任务是：好好学习天天向上
意思是在父类的基础上重新添加代码
"""
s.qita()

3.字类可以初始化，可以理解为，字类可以有构造方法吗

代码

class student(person):
    def __init__(self, name,hobbit,sex="男", age=18,):
       self.hobbit = hobbit

4.那么初始化的时候，能不能保留父类的初始化呢

代码

class student(person):
    def __init__(self, name, hobbit,sex="男", age=18):
        #引用父类的初始化
        super().__init__(name, sex=sex, age=age)
        self.hobbit = hobbit
s = student("小明","打游戏")
print(s.name)
print(s.age)

公有 私有

静态属性：直接写在类里面的是静态属性

动态属性：写在初始化里面的是动态属性，因为它可以改变

静态方法：staticmethod

普通方法：

公有：公共的

私有：不允许外部访问的，私有的

组合起来有：公有静态属性、公有动态属性、公有静态方法、公有普通方法

? 私有静态属性、私有动态属性、私有静态方法、私有普通方法

公有静态属性

class person():
    food = "馒头，公有静态属性" #比如所有的人喜欢吃馒头
    def eat(self): #类内部访问
        print("所有的人喜欢吃"+self.food) 

class student(person):
    def studentEat(self):#派生类访问
        print("学生喜欢吃"+self.food)

#类访问。就是类自己可以访问
print(person.food)

#类内部访问
p = person()
p.eat()

#派生类访问
s =  student()
s.studentEat()

私有静态属性

class person():
    __gongju = "手机，私有静态属性"
    def wan(self):#类内部访问
        print(self.__gongju)
    
class student(person):
    def chagang(self):#派生类访问
        print(self.__gongju,"这是能随便查的吗")

#类访问----->报错
#print(person.__gongju )  

#类内部访问
p = person()
p.wan()

#派生类访问--->报错
s= student()
s.chagang()

公有动态属性

"""
通过对象访问
类内部可以访问:类的内部的某个方法
派生类可以访问: 类1继承类2，类1是派生类
"""
class person():
    def __init__(self,name,sex,age):
        #以下这些属于公有字段/成员变量
        self.name = name
        self.sex = sex
        self.age =age
    def perShow(self):#类内部访问
        print(self.name)
        print(self.sex)
        print(self.age)

class student(person):
    def show(self):#派生类的使用
        print(self.name)
        print(self.sex)
        print(self.age)

#通过对象访问
p = person("张三","男",18)
print(p.name)

#类内部可以访问
p.perShow()

#派生类可以访问
s = student("小明","男",70)
s.show()

私有动态字段

class person():
    def __init__(self,name,phone,idCar):
        self.name = name #公有字段
        self.__phone = phone #私有字段
        self.__idCar = idCar #私有字段
    def perShow(self):#类内部访问
        print(self.name)
        print(self.__phone)
        print(self.__idCar)
    
class student(person):
    def show(self):#派生类的使用
        print(self.name)
        print(self.__phone)
        print(self.__idCar)

#通过对象访问-----失败报错
p = person("张三","11111111111","223456789098865432")
#print(p.name)
#print(p.__idCar)
#print(p.__phone)

#类内部可以访问----成功
p.perShow()

#派生类可以访问----失败报错
s = student("xiaoming","11111111111","223456789098865432")
s.show()

"""
总结：私有的普通字段只能在类的内部访问
"""

公有普通方法

class person():
    def drink(self):
        print("所有人都得喝水,公有的普通方法")
    def he(self):#类内部
        self.drink()


class student(person):
    pass

#类对象访问
p = person()
p.drink()

#类内部
p.he()

#派生类访问
s = student()
s.drink()

私有普通方法

class person():
    def __wc(self):
        print("厕所，私有普通方法")
    def Wcc(self):#类内部访问
        self.__wc()
class student(person):
    pass

#对象访问----->报错
p = person()
#p.__wc()

#类内部访问---->成功
p.Wcc()

#派生类访问---->报错
s = student()
s.__wc()

公有静态方法

"""
静态方法的关键字:staticmethod  [?meθ?d]方法
语法：@staticmethod
"""
class person():
    @staticmethod
    def jiaoliu():
        print("所有的人都有朋友,公有的静态方法")
    def aihao(self):#类内部访问
        self.jiaoliu()

class student(person):
    pass

#对象访问
p = person()
p.jiaoliu()

#类内部访问
p.aihao()

#派生类访问
s = student()
s.jiaoliu()
#类直接访问
person.jiaoliu()

私有静态方法

class person():
    @staticmethod
    def __jiaoliu():
        print("所有的人都有朋友,公有的静态方法")
    def aihao(self):#类内部访问
        self.__jiaoliu()

class student(person):
    pass

#对象访问 ---->报错
p = person()
#p.jiaoliu()

#类内部访问
p.aihao()

#派生类访问---->报错
s = student()
#s.jiaoliu()
#类直接访问
#person.jiaoliu()

总结

"""
公有静态属性：1.类访问 2.类内部访问 3.派生类访问
私有静态属性：只能类内部访问
------------------------------------------------
公有动态属性：1.类对象 2.类内部访问 3.派生类访问
私有动态属性：只能类内部访问
------------------------------------------------
公有普通方法：1.类对象 2.类内部访问 3.派生类访问
私有普通方法：只能类内部访问
----------------------------------------------
公有静态方法：1.类对象 2.类内部访问 3.派生类访问 4.类直接访问
私有静态方法：只能类内部访问
"""

封装

class person():
    #初始化
    def __init__(self,name,sex,age,phone,idCar):
        self.__name = name
        self.__sex = sex
        self.__age = age
        self.__phone = phone
        self.__idCar = idCar
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
    def __wc(self):
        print("wc")
    def show(self):
        print(self.__name )
        print(self.__sex) 
        print(self.__age)
        print(self.__phone)
        print(self.__idCar)

多态

一个对象多种形态

举例，比如动物类，所有的动物都要吃饭，但是狗类吃的骨头，猫类吃的鱼

那怎么让一个动物类的吃有多种形式呢，在狗和猫这两个子类中重写eat方法

class animal():
    def __init__(self,name):
        self.name = name 
    def eat(self):
        print("吃饭")
        
class dog(animal):
    def eat(self):
        print("吃骨头")

class cat(animal):
    def eat(self):
        print("吃鱼")

d = dog("哈士奇")
print(d.name)
d.eat()

c = cat("白猫")
print(c.name)
c.eat()

练习

"""
定义一个名为Vehicles（交通工具）的基类，
   私有属性brand（商标）和color（颜色），
   成员方法run（行驶）和showInfo（显示信息，在控制台显示商标和颜色），并编写构造方法初始化其成员属性。
编写Car（小汽车）类继承于Vehicles类，增加int型成员属性seats（座位），增加成员方法showCar（在控制台显示小汽车的信息），并编写构造方法。
编写Truck（卡车）类继承于Vehicles类，增加float型成员属性load（载重），增加成员方法showTruck（在控制台显示卡车的信息），并编写构造方法。
"""
class Vehicles():
    def __init__(self,brand,color):
        self.__brand = brand         
        self.__color = color

    def run(self):
        print("我已经开动了")
    def showInfo(self):
        print(self.__brand,self.__color)

class Car(Vehicles):
    def __init__(self,brand,color,seats):
        super().__init__(brand,color)
        self.__seats = seats
    def showCar(self):
        self.showInfo()
        print(self.__seats)
class Truck(Vehicles):
    def __init__(self,brand,color,load):
        super().__init__(brand,color)
        self.__load = load
    def showTruck(self):
        self.showInfo()
        print(self.__load)

c = Car("7Q","绿色",5)
c.run()
c.showCar()
t = Truck("五菱宏光","蓝色",6.66)
t.run()
t.showTruck()